#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("&$0")>]
type Ref<'T> = class end
#else
type Ref<'T> = 'T
#endif

#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::ffi::OsString")>]
#endif
type std_ffi_OsString = class end
#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("chrono::DateTime<$0>")>]
#endif
type chrono_DateTime<'T> = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("chrono::NaiveDateTime")>]
#endif
type chrono_NaiveDateTime = class end
#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
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
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("str")>]
type Str = class end
#else
type Str = string
#endif

type IFsExistsSync = abstract existsSync: path: string -> bool
#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("std::string::FromUtf8Error")>]
#endif
type std_string_FromUtf8Error = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("chrono::Utc")>]
#endif
type chrono_Utc = class end
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("chrono::Local")>]
#endif
type chrono_Local = class end
type IPathJoin = abstract join: [<System.ParamArray>] paths: string[] -> string
type Disposable (f : unit -> unit) = interface System.IDisposable with member _.Dispose () = f ()
type IPathDirname = abstract dirname: path: string -> string
#if FABLE_COMPILER
[<Fable.Core.Erase; Fable.Core.Emit("regex::Error")>]
#endif
type regex_Error = 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
    | US4_1
    | US4_2
and [<Struct>] US5 =
    | US5_0 of f0_0 : US4
    | US5_1 of f1_0 : US4
    | US5_2 of f2_0 : US4
    | US5_3 of f3_0 : US4
    | US5_4 of f4_0 : US4
and [<Struct>] US7 =
    | US7_0
    | US7_1
    | US7_2
and [<Struct>] US8 =
    | US8_0
    | US8_1
    | US8_2
    | US8_3
    | US8_4
and [<Struct>] US6 =
    | US6_0 of f0_0 : US7 * f0_1 : US8
    | US6_1
and [<Struct>] US9 =
    | US9_0 of f0_0 : int64
    | US9_1 of f1_0 : exn
and [<Struct>] US10 =
    | US10_0 of f0_0 : int64
    | US10_1 of f1_0 : exn
and [<Struct>] US11 =
    | US11_0 of f0_0 : chrono_DateTime<chrono_Utc>
    | US11_1
and [<Struct>] US12 =
    | US12_0
    | US12_1 of f1_0 : std_string_String
and [<Struct>] US13 =
    | US13_0 of f0_0 : std_path_PathBuf
    | US13_1 of f1_0 : string
and [<Struct>] US14 =
    | US14_0 of f0_0 : std_path_PathBuf
    | US14_1
and [<Struct>] US15 =
    | US15_0 of f0_0 : string
    | US15_1 of f1_0 : string
let rec method1 () : string =
    let v0 : string = "TRACE_LEVEL"
    v0
and method3 () : string =
    let v0 : string = ""
    v0
and closure1 () (v0 : string) : US1 =
    US1_0(v0)
and method4 () : (string -> US1) =
    closure1()
and method2 (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 = method3()
    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 = method3()
    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 = method3()
    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) = method4()
    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) = method4()
    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 method5 () : string =
    let v0 : string = "AUTOMATION"
    v0
and closure2 () (v0 : string) : unit =
    ()
and method0 (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 = method1()
    let v3 : string = method2(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 = method5()
    let v51 : string = method2(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 = method1()
    let v169 : string = method2(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 = method5()
    let v217 : string = method2(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 = method1()
    let v230 : string = method2(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 = method5()
    let v278 : string = method2(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 = method1()
    let v291 : string = method2(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 = method5()
    let v339 : string = method2(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) = closure2()
    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 closure0 () () : 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) = method0(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 method8 (v0 : string) : string =
    v0
and method9 (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 method7 (v0 : bool, v1 : string) : unit =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : string = method8(v1)
    let v4 : bool = method9(v3)
    if v4 then
        if v0 then
            let v5 : string = "std::fs::remove_dir_all(&*$0).unwrap()"
            Fable.Core.RustInterop.emitRustExpr v3 v5 
            ()
        else
            let v6 : string = "std::fs::remove_dir(&*$0).unwrap()"
            Fable.Core.RustInterop.emitRustExpr v3 v6 
            ()
    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.Directory.Delete (v1, v0)
    let _v2 = () 
    #endif
    _v2 
    ()
and method10 (v0 : US0) : bool =
    let v1 : unit = ()
    let v2 : (unit -> unit) = closure0()
    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 closure5 () (v0 : int64) : US3 =
    US3_0(v0)
and method12 () : (int64 -> US3) =
    closure5()
and method13 () : string =
    let v0 : string = "hh:mm:ss"
    v0
and method14 () : string =
    let v0 : string = "HH:mm:ss"
    v0
and method11 (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) = method12()
    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 = method13()
    let v64 : (string -> string) = v60.ToString
    let v65 : string = v64 v61
    let _v6 = v65 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v68 : (int64 -> US3) = method12()
    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 = method13()
    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) = method12()
    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) = method12()
    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 = method14()
    let v221 : (string -> string) = v217.ToString
    let v222 : string = v221 v218
    let _v6 = v222 
    #endif
#if FABLE_COMPILER_PYTHON
    let v225 : (int64 -> US3) = method12()
    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 = method14()
    let v282 : (string -> string) = v278.ToString
    let v283 : string = v282 v279
    let _v6 = v283 
    #endif
#else
    let v286 : (int64 -> US3) = method12()
    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 = method14()
    let v343 : (string -> string) = v339.ToString
    let v344 : string = v343 v340
    let _v6 = v344 
    #endif
    let v347 : string = _v6 
    v347
and method17 () : string =
    let v0 : string = ""
    v0
and closure6 (v0 : Mut3, v1 : string) () : unit =
    let v2 : string = v0.l0
    let v3 : string = v2 + v1 
    v0.l0 <- v3
    ()
and method16 (v0 : char) : string =
    let v1 : string = method17()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = $"{v0}"
    let v6 : unit = ()
    let v7 : (unit -> unit) = closure6(v2, v3)
    let v8 : unit = (fun () -> v7 (); v6) ()
    let v11 : string = v2.l0
    v11
and method18 () : string =
    let v0 : string = "\u001b[0m"
    v0
and method15 () : string =
    
    
    
    
    
    let v0 : string = "Debug"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method16(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 = method18()
    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 = method18()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[94m"
    let v104 : string = method18()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method19 (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) = method4()
    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 : US4 = US4_1
    let v126 : US5 = US5_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 : US4 = US4_0
    let v133 : US5 = US5_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 : US4 = US4_0
    let v137 : US5 = US5_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 method21 (v0 : string, v1 : string) : string =
    let v2 : string = method17()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure6(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "ex"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure6(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure6(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure6(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure6(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "path"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure6(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure6(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure6(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure6(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method22 (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 method20 (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 = method21(v8, v9)
    let v11 : int64 = v0.l0
    let v12 : string = "file_system.delete_directory_async"
    let v13 : string = $"{v6} {v7} #{v11} %s{v12} / {v10}"
    method22(v13)
and closure7 (v0 : Mut0) () : unit =
    let v1 : int64 = v0.l0
    let v2 : int64 = v1 + 1L
    v0.l0 <- v2
    ()
and closure9 (v0 : string) () : unit =
    let v1 : (string -> unit) = System.Console.WriteLine
    v1 v0
and closure8 () (v0 : string) : unit =
    let v1 : unit = ()
    let v2 : (unit -> unit) = closure9(v0)
    let v3 : unit = (fun () -> v2 (); v1) ()
    ()
and method23 (v0 : string) : unit =
    let v1 : unit = ()
    let v2 : (unit -> unit) = closure0()
    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) = closure7(v17)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : (string -> unit) = closure8()
    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 closure4 (v0 : string, v1 : string) () : unit =
    let v2 : US0 = US0_1
    let v3 : bool = method10(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure0()
        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 = method11(v20, v21, v22, v23, v24, v25)
        let v39 : string = method15()
        let v40 : string = method19(v0)
        let v41 : string = method20(v20, v21, v22, v23, v24, v25, v38, v39, v1, v40)
        method23(v41)
and method6 (v0 : string, v1 : int64) : Async<int64> =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v9 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v12 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v12 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v15 
    #endif
#else
    let v18 : Async<int64> option = None
    let mutable _v18 = v18 
    async {
    try
    let v19 : bool = true
    method7(v19, v0)
    return v1 
    with ex ->
    let v20 : exn = ex
    let v21 : int64 = v1 % 100L
    let v22 : bool = v21 = 0L
    if v22 then
        let v23 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v24 : string = $"%A{v20}"
        let _v23 = v24 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v27 : string = $"%A{v20}"
        let _v23 = v27 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v30 : string = $"%A{v20}"
        let _v23 = v30 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v33 : string = $"%A{v20}"
        let _v23 = v33 
        #endif
#if FABLE_COMPILER_PYTHON
        let v36 : string = $"%A{v20}"
        let _v23 = v36 
        #endif
#else
        let v39 : string = $"{v20.GetType ()}: {v20.Message}"
        let _v23 = v39 
        #endif
        let v40 : string = _v23 
        let v45 : unit = ()
        let v46 : (unit -> unit) = closure4(v0, v40)
        let v47 : unit = (fun () -> v46 (); v45) ()
        ()
    let v88 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v89 : Async<unit> = null |> unbox<Async<unit>>
    let _v88 = v89 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v92 : Async<unit> = null |> unbox<Async<unit>>
    let _v88 = v92 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v95 : Async<unit> = null |> unbox<Async<unit>>
    let _v88 = v95 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v98 : Async<unit> = null |> unbox<Async<unit>>
    let _v88 = v98 
    #endif
#if FABLE_COMPILER_PYTHON
    let v101 : Async<unit> = null |> unbox<Async<unit>>
    let _v88 = v101 
    #endif
#else
    let v104 : (int32 -> Async<unit>) = Async.Sleep
    let v105 : Async<unit> = v104 10
    let _v88 = v105 
    #endif
    let v106 : Async<unit> = _v88 
    do! v106 
    let v111 : int64 = v1 + 1L
    let v112 : Async<int64> = method6(v0, v111)
    return! v112 
    (*
    let v113 : int64 = *)
    }
    |> fun x -> _v18 <- Some x
    let v114 : Async<int64> = match _v18 with Some x -> x | None -> failwith "async.new_async_unit / _v18=None"
    let _v2 = v114 
    #endif
    let v115 : Async<int64> = _v2 
    v115
and closure3 () (v0 : string) : Async<int64> =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v11 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v11 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v14 
    #endif
#else
    let v17 : int64 = 0L
    let v18 : Async<int64> = method6(v0, v17)
    let _v1 = v18 
    #endif
    let v19 : Async<int64> = _v1 
    v19
and method26 (v0 : string, v1 : int64, v2 : string) : string =
    let v3 : string = method17()
    let v4 : Mut3 = {l0 = v3} : Mut3
    let v5 : string = "{ "
    let v6 : string = $"{v5}"
    let v9 : unit = ()
    let v10 : (unit -> unit) = closure6(v4, v6)
    let v11 : unit = (fun () -> v10 (); v9) ()
    let v14 : string = "path"
    let v15 : string = $"{v14}"
    let v18 : unit = ()
    let v19 : (unit -> unit) = closure6(v4, v15)
    let v20 : unit = (fun () -> v19 (); v18) ()
    let v23 : string = " = "
    let v24 : string = $"{v23}"
    let v27 : unit = ()
    let v28 : (unit -> unit) = closure6(v4, v24)
    let v29 : unit = (fun () -> v28 (); v27) ()
    let v32 : string = $"{v0}"
    let v35 : unit = ()
    let v36 : (unit -> unit) = closure6(v4, v32)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : string = "; "
    let v41 : string = $"{v40}"
    let v44 : unit = ()
    let v45 : (unit -> unit) = closure6(v4, v41)
    let v46 : unit = (fun () -> v45 (); v44) ()
    let v49 : string = "retry"
    let v50 : string = $"{v49}"
    let v53 : unit = ()
    let v54 : (unit -> unit) = closure6(v4, v50)
    let v55 : unit = (fun () -> v54 (); v53) ()
    let v58 : string = $"{v23}"
    let v61 : unit = ()
    let v62 : (unit -> unit) = closure6(v4, v58)
    let v63 : unit = (fun () -> v62 (); v61) ()
    let v66 : string = $"{v1}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure6(v4, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = $"{v40}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure6(v4, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = "ex"
    let v83 : string = $"{v82}"
    let v86 : unit = ()
    let v87 : (unit -> unit) = closure6(v4, v83)
    let v88 : unit = (fun () -> v87 (); v86) ()
    let v91 : string = $"{v23}"
    let v94 : unit = ()
    let v95 : (unit -> unit) = closure6(v4, v91)
    let v96 : unit = (fun () -> v95 (); v94) ()
    let v99 : string = $"{v2}"
    let v102 : unit = ()
    let v103 : (unit -> unit) = closure6(v4, v99)
    let v104 : unit = (fun () -> v103 (); v102) ()
    let v107 : string = " }"
    let v108 : string = $"{v107}"
    let v111 : unit = ()
    let v112 : (unit -> unit) = closure6(v4, v108)
    let v113 : unit = (fun () -> v112 (); v111) ()
    let v116 : string = v4.l0
    v116
and method25 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : int64, v10 : string) : string =
    let v11 : string = method26(v8, v9, v10)
    let v12 : int64 = v0.l0
    let v13 : string = "file_system.wait_for_file_access"
    let v14 : string = $"{v6} {v7} #{v12} %s{v13} / {v11}"
    method22(v14)
and closure12 (v0 : string, v1 : int64, v2 : string) () : unit =
    let v3 : US0 = US0_1
    let v4 : bool = method10(v3)
    if v4 then
        let v5 : unit = ()
        let v6 : (unit -> unit) = closure0()
        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 = method11(v21, v22, v23, v24, v25, v26)
        let v40 : string = method15()
        let v41 : string = method19(v0)
        let v42 : string = method25(v21, v22, v23, v24, v25, v26, v39, v40, v41, v1, v2)
        method23(v42)
and method24 (v0 : string, v1 : US8, v2 : US7, v3 : int64) : Async<int64> =
    let v4 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v5 : Async<int64> = null |> unbox<Async<int64>>
    let _v4 = v5 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v8 : Async<int64> = null |> unbox<Async<int64>>
    let _v4 = v8 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v11 : Async<int64> = null |> unbox<Async<int64>>
    let _v4 = v11 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v14 : Async<int64> = null |> unbox<Async<int64>>
    let _v4 = v14 
    #endif
#if FABLE_COMPILER_PYTHON
    let v17 : Async<int64> = null |> unbox<Async<int64>>
    let _v4 = v17 
    #endif
#else
    let v20 : Async<int64> option = None
    let mutable _v20 = v20 
    async {
    try
    let v21 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v22 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v21 = v22 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v25 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v21 = v25 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v28 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v21 = v28 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v31 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v21 = v31 
    #endif
#if FABLE_COMPILER_PYTHON
    let v34 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v21 = v34 
    #endif
#else
    let v37 : System.IO.FileMode = System.IO.FileMode.Open
    let v43 : System.IO.FileAccess =
        match v2 with
        | US7_0 -> (* AccessRead *)
            let v38 : System.IO.FileAccess = System.IO.FileAccess.Read
            v38
        | US7_2 -> (* AccessReadWrite *)
            let v40 : System.IO.FileAccess = System.IO.FileAccess.ReadWrite
            v40
        | US7_1 -> (* AccessWrite *)
            let v39 : System.IO.FileAccess = System.IO.FileAccess.ReadWrite
            v39
    let v53 : System.IO.FileShare =
        match v1 with
        | US8_4 -> (* ShareDelete *)
            let v48 : System.IO.FileShare = System.IO.FileShare.Delete
            v48
        | US8_0 -> (* ShareNone *)
            let v44 : System.IO.FileShare = System.IO.FileShare.None
            v44
        | US8_1 -> (* ShareRead *)
            let v45 : System.IO.FileShare = System.IO.FileShare.Read
            v45
        | US8_3 -> (* ShareReadWrite *)
            let v47 : System.IO.FileShare = System.IO.FileShare.ReadWrite
            v47
        | US8_2 -> (* ShareWrite *)
            let v46 : System.IO.FileShare = System.IO.FileShare.Write
            v46
    let v54 : System.IO.FileStream = new System.IO.FileStream (v0, v37, v43, v53)
    let _v21 = v54 
    #endif
    let v55 : System.IO.FileStream = _v21 
    use v55 = v55 
    let v60 : System.IO.FileStream = v55 
    return v3 
    with ex ->
    let v61 : exn = ex
    let v62 : bool = v3 > 0L
    let v65 : bool =
        if v62 then
            let v63 : int64 = v3 % 100L
            let v64 : bool = v63 = 0L
            v64
        else
            false
    if v65 then
        let v66 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v67 : string = $"%A{v61}"
        let _v66 = v67 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v70 : string = $"%A{v61}"
        let _v66 = v70 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v73 : string = $"%A{v61}"
        let _v66 = v73 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v76 : string = $"%A{v61}"
        let _v66 = v76 
        #endif
#if FABLE_COMPILER_PYTHON
        let v79 : string = $"%A{v61}"
        let _v66 = v79 
        #endif
#else
        let v82 : string = $"{v61.GetType ()}: {v61.Message}"
        let _v66 = v82 
        #endif
        let v83 : string = _v66 
        let v88 : unit = ()
        let v89 : (unit -> unit) = closure12(v0, v3, v83)
        let v90 : unit = (fun () -> v89 (); v88) ()
        ()
    let v131 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v132 : Async<unit> = null |> unbox<Async<unit>>
    let _v131 = v132 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v135 : Async<unit> = null |> unbox<Async<unit>>
    let _v131 = v135 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v138 : Async<unit> = null |> unbox<Async<unit>>
    let _v131 = v138 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v141 : Async<unit> = null |> unbox<Async<unit>>
    let _v131 = v141 
    #endif
#if FABLE_COMPILER_PYTHON
    let v144 : Async<unit> = null |> unbox<Async<unit>>
    let _v131 = v144 
    #endif
#else
    let v147 : (int32 -> Async<unit>) = Async.Sleep
    let v148 : Async<unit> = v147 10
    let _v131 = v148 
    #endif
    let v149 : Async<unit> = _v131 
    do! v149 
    let v154 : int64 = v3 + 1L
    let v155 : Async<int64> = method24(v0, v1, v2, v154)
    return! v155 
    (*
    let v156 : int64 = *)
    }
    |> fun x -> _v20 <- Some x
    let v157 : Async<int64> = match _v20 with Some x -> x | None -> failwith "async.new_async_unit / _v20=None"
    let _v4 = v157 
    #endif
    let v158 : Async<int64> = _v4 
    v158
and closure11 (v0 : US6) (v1 : string) : Async<int64> =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v9 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v12 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v12 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v15 
    #endif
#else
    let struct (v24 : US7, v25 : US8) =
        match v0 with
        | US6_1 -> (* None *)
            let v20 : US7 = US7_2
            let v21 : US8 = US8_1
            struct (v20, v21)
        | US6_0(v18, v19) -> (* Some *)
            struct (v18, v19)
    let v26 : int64 = 0L
    let v27 : Async<int64> = method24(v1, v25, v24, v26)
    let _v2 = v27 
    #endif
    let v28 : Async<int64> = _v2 
    v28
and closure10 () (v0 : US6) : (string -> Async<int64>) =
    closure11(v0)
and method27 (v0 : string, v1 : int64) : Async<int64> =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v9 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v12 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v12 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v15 
    #endif
#else
    let v18 : Async<int64> option = None
    let mutable _v18 = v18 
    async {
    try
    let v19 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v20 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v19 = v20 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v23 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v19 = v23 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v26 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v19 = v26 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v29 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v19 = v29 
    #endif
#if FABLE_COMPILER_PYTHON
    let v32 : System.IO.FileStream = null |> unbox<System.IO.FileStream>
    let _v19 = v32 
    #endif
#else
    let v35 : System.IO.FileMode = System.IO.FileMode.Open
    let v36 : System.IO.FileAccess = System.IO.FileAccess.Read
    let v37 : System.IO.FileShare = System.IO.FileShare.Read
    let v38 : System.IO.FileStream = new System.IO.FileStream (v0, v35, v36, v37)
    let _v19 = v38 
    #endif
    let v39 : System.IO.FileStream = _v19 
    use v39 = v39 
    let v44 : System.IO.FileStream = v39 
    return v1 
    with ex ->
    let v45 : exn = ex
    let v46 : bool = v1 > 0L
    let v49 : bool =
        if v46 then
            let v47 : int64 = v1 % 100L
            let v48 : bool = v47 = 0L
            v48
        else
            false
    if v49 then
        let v50 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v51 : string = $"%A{v45}"
        let _v50 = v51 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v54 : string = $"%A{v45}"
        let _v50 = v54 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v57 : string = $"%A{v45}"
        let _v50 = v57 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v60 : string = $"%A{v45}"
        let _v50 = v60 
        #endif
#if FABLE_COMPILER_PYTHON
        let v63 : string = $"%A{v45}"
        let _v50 = v63 
        #endif
#else
        let v66 : string = $"{v45.GetType ()}: {v45.Message}"
        let _v50 = v66 
        #endif
        let v67 : string = _v50 
        let v72 : unit = ()
        let v73 : (unit -> unit) = closure12(v0, v1, v67)
        let v74 : unit = (fun () -> v73 (); v72) ()
        ()
    let v115 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v116 : Async<unit> = null |> unbox<Async<unit>>
    let _v115 = v116 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v119 : Async<unit> = null |> unbox<Async<unit>>
    let _v115 = v119 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v122 : Async<unit> = null |> unbox<Async<unit>>
    let _v115 = v122 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v125 : Async<unit> = null |> unbox<Async<unit>>
    let _v115 = v125 
    #endif
#if FABLE_COMPILER_PYTHON
    let v128 : Async<unit> = null |> unbox<Async<unit>>
    let _v115 = v128 
    #endif
#else
    let v131 : (int32 -> Async<unit>) = Async.Sleep
    let v132 : Async<unit> = v131 10
    let _v115 = v132 
    #endif
    let v133 : Async<unit> = _v115 
    do! v133 
    let v138 : int64 = v1 + 1L
    let v139 : Async<int64> = method27(v0, v138)
    return! v139 
    (*
    let v140 : int64 = *)
    }
    |> fun x -> _v18 <- Some x
    let v141 : Async<int64> = match _v18 with Some x -> x | None -> failwith "async.new_async_unit / _v18=None"
    let _v2 = v141 
    #endif
    let v142 : Async<int64> = _v2 
    v142
and closure13 () (v0 : string) : Async<int64> =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v11 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v11 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v14 
    #endif
#else
    let v17 : int64 = 0L
    let v18 : Async<int64> = method27(v0, v17)
    let _v1 = v18 
    #endif
    let v19 : Async<int64> = _v1 
    v19
and closure14 () (v0 : string) : Async<string> =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : Async<string> = null |> unbox<Async<string>>
    let _v1 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : Async<string> = null |> unbox<Async<string>>
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : Async<string> = null |> unbox<Async<string>>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v11 : Async<string> = null |> unbox<Async<string>>
    let _v1 = v11 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : Async<string> = null |> unbox<Async<string>>
    let _v1 = v14 
    #endif
#else
    let v17 : (string -> System.Threading.Tasks.Task<string>) = System.IO.File.ReadAllTextAsync
    let v18 : System.Threading.Tasks.Task<string> = v17 v0
    let v19 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v20 : Async<string> = null |> unbox<Async<string>>
    let _v19 = v20 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v23 : Async<string> = null |> unbox<Async<string>>
    let _v19 = v23 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v26 : Async<string> = null |> unbox<Async<string>>
    let _v19 = v26 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v29 : Async<string> = null |> unbox<Async<string>>
    let _v19 = v29 
    #endif
#if FABLE_COMPILER_PYTHON
    let v32 : Async<string> = null |> unbox<Async<string>>
    let _v19 = v32 
    #endif
#else
    let v35 : (System.Threading.Tasks.Task<string> -> Async<string>) = Async.AwaitTask
    let v36 : Async<string> = v35 v18
    let _v19 = v36 
    #endif
    let v37 : Async<string> = _v19 
    let _v1 = v37 
    #endif
    let v42 : Async<string> = _v1 
    v42
and method29 (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 method30 (v0 : Vec<uint8>) : Vec<uint8> =
    v0
and method28 (v0 : string, v1 : string) : bool =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : bool = method29(v0)
    let v4 : bool = v3 = false
    let v79 : bool =
        if v4 then
            false
        else
            let v5 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v6 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v7 : string = "std::fs::read(&*$0)"
            let v8 : Result<Vec<uint8>, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v0 v7 
            let v9 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v10 : string = "$0.unwrap()"
            let v11 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v8 v10 
            let _v9 = v11 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v12 : string = "$0.unwrap()"
            let v13 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v8 v12 
            let _v9 = v13 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v14 : string = "$0.unwrap()"
            let v15 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v8 v14 
            let _v9 = v15 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v16 : Vec<uint8> = match v8 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v9 = v16 
            #endif
#if FABLE_COMPILER_PYTHON
            let v17 : Vec<uint8> = match v8 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v9 = v17 
            #endif
#else
            let v18 : Vec<uint8> = match v8 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v9 = v18 
            #endif
            let v19 : Vec<uint8> = _v9 
            let _v6 = v19 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v22 : Vec<uint8> = null |> unbox<Vec<uint8>>
            let _v6 = v22 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v25 : Vec<uint8> = null |> unbox<Vec<uint8>>
            let _v6 = v25 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v28 : Vec<uint8> = null |> unbox<Vec<uint8>>
            let _v6 = v28 
            #endif
#if FABLE_COMPILER_PYTHON
            let v31 : Vec<uint8> = null |> unbox<Vec<uint8>>
            let _v6 = v31 
            #endif
#else
            let v34 : (uint8 []) = v0 |> System.IO.File.ReadAllBytes
            let v35 : string = "$0.to_vec()"
            let v36 : Vec<uint8> = Fable.Core.RustInterop.emitRustExpr v34 v35 
            let _v6 = v36 
            #endif
            let v37 : Vec<uint8> = _v6 
            let v42 : Vec<uint8> = method30(v37)
            let v43 : string = "std::string::String::from_utf8($0)"
            let v44 : Result<std_string_String, std_string_FromUtf8Error> = Fable.Core.RustInterop.emitRustExpr v42 v43 
            let v45 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v46 : string = "$0.unwrap()"
            let v47 : std_string_String = Fable.Core.RustInterop.emitRustExpr v44 v46 
            let _v45 = v47 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v48 : string = "$0.unwrap()"
            let v49 : std_string_String = Fable.Core.RustInterop.emitRustExpr v44 v48 
            let _v45 = v49 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v50 : string = "$0.unwrap()"
            let v51 : std_string_String = Fable.Core.RustInterop.emitRustExpr v44 v50 
            let _v45 = v51 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v52 : std_string_String = match v44 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v45 = v52 
            #endif
#if FABLE_COMPILER_PYTHON
            let v53 : std_string_String = match v44 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v45 = v53 
            #endif
#else
            let v54 : std_string_String = match v44 with Ok x -> x | Error e -> failwith $"resultm.unwrap' / e: {e}"
            let _v45 = v54 
            #endif
            let v55 : std_string_String = _v45 
            let v58 : string = "fable_library_rust::String_::fromString($0)"
            let v59 : string = Fable.Core.RustInterop.emitRustExpr v55 v58 
            let _v5 = v59 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v60 : string = null |> unbox<string>
            let _v5 = v60 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v63 : string = null |> unbox<string>
            let _v5 = v63 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v66 : string = null |> unbox<string>
            let _v5 = v66 
            #endif
#if FABLE_COMPILER_PYTHON
            let v69 : string = null |> unbox<string>
            let _v5 = v69 
            #endif
#else
            let v72 : string = v0 |> System.IO.File.ReadAllText
            let _v5 = v72 
            #endif
            let v73 : string = _v5 
            let v78 : bool = v1 = v73
            v78
    let _v2 = v79 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v80 : bool = null |> unbox<bool>
    let _v2 = v80 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v83 : bool = null |> unbox<bool>
    let _v2 = v83 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v86 : bool = null |> unbox<bool>
    let _v2 = v86 
    #endif
#if FABLE_COMPILER_PYTHON
    let v89 : bool = null |> unbox<bool>
    let _v2 = v89 
    #endif
#else
    let v92 : bool = null |> unbox<bool>
    let _v2 = v92 
    #endif
    let v95 : bool = _v2 
    v95
and closure16 (v0 : string) (v1 : string) : bool =
    method28(v0, v1)
and closure15 () (v0 : string) : (string -> bool) =
    closure16(v0)
and closure18 (v0 : string) (v1 : string) : Async<unit> =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v9 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v12 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v12 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v15 
    #endif
#else
    let v18 : System.Threading.Tasks.Task = System.IO.File.WriteAllTextAsync (v0, v1)
    let v19 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v20 : Async<unit> = null |> unbox<Async<unit>>
    let _v19 = v20 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v23 : Async<unit> = null |> unbox<Async<unit>>
    let _v19 = v23 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v26 : Async<unit> = null |> unbox<Async<unit>>
    let _v19 = v26 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v29 : Async<unit> = null |> unbox<Async<unit>>
    let _v19 = v29 
    #endif
#if FABLE_COMPILER_PYTHON
    let v32 : Async<unit> = null |> unbox<Async<unit>>
    let _v19 = v32 
    #endif
#else
    let v35 : (System.Threading.Tasks.Task -> Async<unit>) = Async.AwaitTask
    let v36 : Async<unit> = v35 v18
    let _v19 = v36 
    #endif
    let v37 : Async<unit> = _v19 
    let _v2 = v37 
    #endif
    let v42 : Async<unit> = _v2 
    v42
and closure17 () (v0 : string) : (string -> Async<unit>) =
    closure18(v0)
and closure20 (v0 : string) (v1 : string) : Async<unit> =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v9 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v12 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v12 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Async<unit> = null |> unbox<Async<unit>>
    let _v2 = v15 
    #endif
#else
    let v18 : Async<unit> option = None
    let mutable _v18 = v18 
    async {
    let v19 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v20 : Async<bool> = null |> unbox<Async<bool>>
    let _v19 = v20 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v23 : Async<bool> = null |> unbox<Async<bool>>
    let _v19 = v23 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v26 : Async<bool> = null |> unbox<Async<bool>>
    let _v19 = v26 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v29 : Async<bool> = null |> unbox<Async<bool>>
    let _v19 = v29 
    #endif
#if FABLE_COMPILER_PYTHON
    let v32 : Async<bool> = null |> unbox<Async<bool>>
    let _v19 = v32 
    #endif
#else
    let v35 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v36 : Async<bool> = null |> unbox<Async<bool>>
    let _v35 = v36 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v39 : Async<bool> = null |> unbox<Async<bool>>
    let _v35 = v39 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v42 : Async<bool> = null |> unbox<Async<bool>>
    let _v35 = v42 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v45 : Async<bool> = null |> unbox<Async<bool>>
    let _v35 = v45 
    #endif
#if FABLE_COMPILER_PYTHON
    let v48 : Async<bool> = null |> unbox<Async<bool>>
    let _v35 = v48 
    #endif
#else
    let v51 : Async<bool> option = None
    let mutable _v51 = v51 
    async {
    let v52 : bool = method29(v0)
    let v53 : bool = v52 = false
    if v53 then
        return false 
        (*
        ()
    else
        *) else
        let v54 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v55 : Async<string> = null |> unbox<Async<string>>
        let _v54 = v55 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v58 : Async<string> = null |> unbox<Async<string>>
        let _v54 = v58 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v61 : Async<string> = null |> unbox<Async<string>>
        let _v54 = v61 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v64 : Async<string> = null |> unbox<Async<string>>
        let _v54 = v64 
        #endif
#if FABLE_COMPILER_PYTHON
        let v67 : Async<string> = null |> unbox<Async<string>>
        let _v54 = v67 
        #endif
#else
        let v70 : (string -> System.Threading.Tasks.Task<string>) = System.IO.File.ReadAllTextAsync
        let v71 : System.Threading.Tasks.Task<string> = v70 v0
        let v72 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v73 : Async<string> = null |> unbox<Async<string>>
        let _v72 = v73 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v76 : Async<string> = null |> unbox<Async<string>>
        let _v72 = v76 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v79 : Async<string> = null |> unbox<Async<string>>
        let _v72 = v79 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v82 : Async<string> = null |> unbox<Async<string>>
        let _v72 = v82 
        #endif
#if FABLE_COMPILER_PYTHON
        let v85 : Async<string> = null |> unbox<Async<string>>
        let _v72 = v85 
        #endif
#else
        let v88 : (System.Threading.Tasks.Task<string> -> Async<string>) = Async.AwaitTask
        let v89 : Async<string> = v88 v71
        let _v72 = v89 
        #endif
        let v90 : Async<string> = _v72 
        let _v54 = v90 
        #endif
        let v95 : Async<string> = _v54 
        let! v95 = v95 
        let v100 : string = v95 
        let v101 : bool = v1 = v100
        return v101 
        (*
        ()
    *)
    }
    |> fun x -> _v51 <- Some x
    let v102 : Async<bool> = match _v51 with Some x -> x | None -> failwith "async.new_async_unit / _v51=None"
    let _v35 = v102 
    #endif
    let v103 : Async<bool> = _v35 
    let _v19 = v103 
    #endif
    let v108 : Async<bool> = _v19 
    let! v108 = v108 
    let v113 : bool = v108 
    let v114 : bool = v113 = false
    if v114 then
        let v115 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v116 : Async<unit> = null |> unbox<Async<unit>>
        let _v115 = v116 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v119 : Async<unit> = null |> unbox<Async<unit>>
        let _v115 = v119 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v122 : Async<unit> = null |> unbox<Async<unit>>
        let _v115 = v122 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v125 : Async<unit> = null |> unbox<Async<unit>>
        let _v115 = v125 
        #endif
#if FABLE_COMPILER_PYTHON
        let v128 : Async<unit> = null |> unbox<Async<unit>>
        let _v115 = v128 
        #endif
#else
        let v131 : System.Threading.Tasks.Task = System.IO.File.WriteAllTextAsync (v0, v1)
        let v132 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v133 : Async<unit> = null |> unbox<Async<unit>>
        let _v132 = v133 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v136 : Async<unit> = null |> unbox<Async<unit>>
        let _v132 = v136 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v139 : Async<unit> = null |> unbox<Async<unit>>
        let _v132 = v139 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v142 : Async<unit> = null |> unbox<Async<unit>>
        let _v132 = v142 
        #endif
#if FABLE_COMPILER_PYTHON
        let v145 : Async<unit> = null |> unbox<Async<unit>>
        let _v132 = v145 
        #endif
#else
        let v148 : (System.Threading.Tasks.Task -> Async<unit>) = Async.AwaitTask
        let v149 : Async<unit> = v148 v131
        let _v132 = v149 
        #endif
        let v150 : Async<unit> = _v132 
        let _v115 = v150 
        #endif
        let v155 : Async<unit> = _v115 
        do! v155 
        ()
    ()
    }
    |> fun x -> _v18 <- Some x
    let v160 : Async<unit> = match _v18 with Some x -> x | None -> failwith "async.new_async_unit / _v18=None"
    let _v2 = v160 
    #endif
    let v161 : Async<unit> = _v2 
    v161
and closure19 () (v0 : string) : (string -> Async<unit>) =
    closure20(v0)
and method32 () : string =
    
    
    
    
    
    let v0 : string = "Warning"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method16(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 = method18()
    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 = method18()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[93m"
    let v104 : string = method18()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method34 (v0 : string, v1 : string) : string =
    let v2 : string = method17()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure6(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "path"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure6(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure6(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure6(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure6(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "ex"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure6(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure6(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure6(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure6(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method33 (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 = method34(v8, v9)
    let v11 : int64 = v0.l0
    let v12 : string = "delete_file_async"
    let v13 : string = $"{v6} {v7} #{v11} %s{v12} / {v10}"
    method22(v13)
and closure22 (v0 : string, v1 : exn) () : unit =
    let v2 : US0 = US0_3
    let v3 : bool = method10(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure0()
        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 = method11(v20, v21, v22, v23, v24, v25)
        let v39 : string = method32()
        let v40 : string = method19(v0)
        let v41 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v42 : string = $"%A{v1}"
        let _v41 = v42 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v45 : string = $"%A{v1}"
        let _v41 = v45 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v48 : string = $"%A{v1}"
        let _v41 = v48 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v51 : string = $"%A{v1}"
        let _v41 = v51 
        #endif
#if FABLE_COMPILER_PYTHON
        let v54 : string = $"%A{v1}"
        let _v41 = v54 
        #endif
#else
        let v57 : string = $"{v1.GetType ()}: {v1.Message}"
        let _v41 = v57 
        #endif
        let v58 : string = _v41 
        let v63 : string = method33(v20, v21, v22, v23, v24, v25, v38, v39, v40, v58)
        method23(v63)
and method31 (v0 : string, v1 : int64) : Async<int64> =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v9 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v12 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v12 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v15 
    #endif
#else
    let v18 : Async<int64> option = None
    let mutable _v18 = v18 
    async {
    try
    let v19 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v20 : string = "std::fs::remove_file(&*$0).unwrap()"
    Fable.Core.RustInterop.emitRustExpr v0 v20 
    let _v19 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let _v19 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let _v19 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let _v19 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    let _v19 = () 
    #endif
#else
    let v21 : (string -> unit) = System.IO.File.Delete
    v21 v0
    let _v19 = () 
    #endif
    _v19 
    return v1 
    with ex ->
    let v22 : exn = ex
    let v23 : int64 = v1 % 100L
    let v24 : bool = v23 = 0L
    if v24 then
        let v25 : unit = ()
        let v26 : (unit -> unit) = closure22(v0, v22)
        let v27 : unit = (fun () -> v26 (); v25) ()
        ()
    let v90 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v91 : Async<unit> = null |> unbox<Async<unit>>
    let _v90 = v91 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v94 : Async<unit> = null |> unbox<Async<unit>>
    let _v90 = v94 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v97 : Async<unit> = null |> unbox<Async<unit>>
    let _v90 = v97 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v100 : Async<unit> = null |> unbox<Async<unit>>
    let _v90 = v100 
    #endif
#if FABLE_COMPILER_PYTHON
    let v103 : Async<unit> = null |> unbox<Async<unit>>
    let _v90 = v103 
    #endif
#else
    let v106 : (int32 -> Async<unit>) = Async.Sleep
    let v107 : Async<unit> = v106 10
    let _v90 = v107 
    #endif
    let v108 : Async<unit> = _v90 
    do! v108 
    let v113 : int64 = v1 + 1L
    let v114 : Async<int64> = method31(v0, v113)
    return! v114 
    (*
    let v115 : int64 = *)
    }
    |> fun x -> _v18 <- Some x
    let v116 : Async<int64> = match _v18 with Some x -> x | None -> failwith "async.new_async_unit / _v18=None"
    let _v2 = v116 
    #endif
    let v117 : Async<int64> = _v2 
    v117
and closure21 () (v0 : string) : Async<int64> =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v11 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v11 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v14 
    #endif
#else
    let v17 : int64 = 0L
    let v18 : Async<int64> = method31(v0, v17)
    let _v1 = v18 
    #endif
    let v19 : Async<int64> = _v1 
    v19
and method37 (v0 : string, v1 : string, v2 : exn) : string =
    let v3 : string = method17()
    let v4 : Mut3 = {l0 = v3} : Mut3
    let v5 : string = "{ "
    let v6 : string = $"{v5}"
    let v9 : unit = ()
    let v10 : (unit -> unit) = closure6(v4, v6)
    let v11 : unit = (fun () -> v10 (); v9) ()
    let v14 : string = "old_path"
    let v15 : string = $"{v14}"
    let v18 : unit = ()
    let v19 : (unit -> unit) = closure6(v4, v15)
    let v20 : unit = (fun () -> v19 (); v18) ()
    let v23 : string = " = "
    let v24 : string = $"{v23}"
    let v27 : unit = ()
    let v28 : (unit -> unit) = closure6(v4, v24)
    let v29 : unit = (fun () -> v28 (); v27) ()
    let v32 : string = $"{v0}"
    let v35 : unit = ()
    let v36 : (unit -> unit) = closure6(v4, v32)
    let v37 : unit = (fun () -> v36 (); v35) ()
    let v40 : string = "; "
    let v41 : string = $"{v40}"
    let v44 : unit = ()
    let v45 : (unit -> unit) = closure6(v4, v41)
    let v46 : unit = (fun () -> v45 (); v44) ()
    let v49 : string = "new_path"
    let v50 : string = $"{v49}"
    let v53 : unit = ()
    let v54 : (unit -> unit) = closure6(v4, v50)
    let v55 : unit = (fun () -> v54 (); v53) ()
    let v58 : string = $"{v23}"
    let v61 : unit = ()
    let v62 : (unit -> unit) = closure6(v4, v58)
    let v63 : unit = (fun () -> v62 (); v61) ()
    let v66 : string = $"{v1}"
    let v69 : unit = ()
    let v70 : (unit -> unit) = closure6(v4, v66)
    let v71 : unit = (fun () -> v70 (); v69) ()
    let v74 : string = $"{v40}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure6(v4, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = "ex"
    let v83 : string = $"{v82}"
    let v86 : unit = ()
    let v87 : (unit -> unit) = closure6(v4, v83)
    let v88 : unit = (fun () -> v87 (); v86) ()
    let v91 : string = $"{v23}"
    let v94 : unit = ()
    let v95 : (unit -> unit) = closure6(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) = closure6(v4, v126)
    let v131 : unit = (fun () -> v130 (); v129) ()
    let v134 : string = " }"
    let v135 : string = $"{v134}"
    let v138 : unit = ()
    let v139 : (unit -> unit) = closure6(v4, v135)
    let v140 : unit = (fun () -> v139 (); v138) ()
    let v143 : string = v4.l0
    v143
and method36 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : string, v10 : exn) : string =
    let v11 : string = method37(v8, v9, v10)
    let v12 : int64 = v0.l0
    let v13 : string = "move_file_async"
    let v14 : string = $"{v6} {v7} #{v12} %s{v13} / {v11}"
    method22(v14)
and closure25 (v0 : string, v1 : string, v2 : exn) () : unit =
    let v3 : US0 = US0_3
    let v4 : bool = method10(v3)
    if v4 then
        let v5 : unit = ()
        let v6 : (unit -> unit) = closure0()
        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 = method11(v21, v22, v23, v24, v25, v26)
        let v40 : string = method32()
        let v41 : string = method19(v1)
        let v42 : string = method19(v0)
        let v43 : string = method36(v21, v22, v23, v24, v25, v26, v39, v40, v41, v42, v2)
        method23(v43)
and method35 (v0 : string, v1 : string, v2 : int64) : Async<int64> =
    let v3 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v4 : Async<int64> = null |> unbox<Async<int64>>
    let _v3 = v4 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v7 : Async<int64> = null |> unbox<Async<int64>>
    let _v3 = v7 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v10 : Async<int64> = null |> unbox<Async<int64>>
    let _v3 = v10 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v13 : Async<int64> = null |> unbox<Async<int64>>
    let _v3 = v13 
    #endif
#if FABLE_COMPILER_PYTHON
    let v16 : Async<int64> = null |> unbox<Async<int64>>
    let _v3 = v16 
    #endif
#else
    let v19 : Async<int64> option = None
    let mutable _v19 = v19 
    async {
    try
    let v20 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let _v20 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let _v20 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let _v20 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let _v20 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    let _v20 = () 
    #endif
#else
    System.IO.File.Move (v1, v0)
    let _v20 = () 
    #endif
    _v20 
    return v2 
    with ex ->
    let v21 : exn = ex
    let v22 : int64 = v2 % 100L
    let v23 : bool = v22 = 0L
    if v23 then
        let v24 : unit = ()
        let v25 : (unit -> unit) = closure25(v0, v1, v21)
        let v26 : unit = (fun () -> v25 (); v24) ()
        ()
    let v68 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v69 : Async<unit> = null |> unbox<Async<unit>>
    let _v68 = v69 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v72 : Async<unit> = null |> unbox<Async<unit>>
    let _v68 = v72 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v75 : Async<unit> = null |> unbox<Async<unit>>
    let _v68 = v75 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v78 : Async<unit> = null |> unbox<Async<unit>>
    let _v68 = v78 
    #endif
#if FABLE_COMPILER_PYTHON
    let v81 : Async<unit> = null |> unbox<Async<unit>>
    let _v68 = v81 
    #endif
#else
    let v84 : (int32 -> Async<unit>) = Async.Sleep
    let v85 : Async<unit> = v84 10
    let _v68 = v85 
    #endif
    let v86 : Async<unit> = _v68 
    do! v86 
    let v91 : int64 = v2 + 1L
    let v92 : Async<int64> = method35(v0, v1, v91)
    return! v92 
    (*
    *)
    }
    |> fun x -> _v19 <- Some x
    let v93 : Async<int64> = match _v19 with Some x -> x | None -> failwith "async.new_async_unit / _v19=None"
    let _v3 = v93 
    #endif
    let v94 : Async<int64> = _v3 
    v94
and closure24 (v0 : string) (v1 : string) : Async<int64> =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v9 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v12 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v12 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Async<int64> = null |> unbox<Async<int64>>
    let _v2 = v15 
    #endif
#else
    let v18 : int64 = 0L
    let v19 : Async<int64> = method35(v0, v1, v18)
    let _v2 = v19 
    #endif
    let v20 : Async<int64> = _v2 
    v20
and closure23 () (v0 : string) : (string -> Async<int64>) =
    closure24(v0)
and closure27 () (v0 : int64) : US9 =
    US9_0(v0)
and closure28 () (v0 : exn) : US9 =
    US9_1(v0)
and method39 () : string =
    
    
    
    
    
    let v0 : string = "Verbose"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method16(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 = method18()
    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 = method18()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[90m"
    let v104 : string = method18()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method41 (v0 : int32) : string =
    let v1 : string = method17()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure6(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "timeout"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure6(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure6(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : string = $"{v0}"
    let v33 : unit = ()
    let v34 : (unit -> unit) = closure6(v2, v30)
    let v35 : unit = (fun () -> v34 (); v33) ()
    let v38 : string = " }"
    let v39 : string = $"{v38}"
    let v42 : unit = ()
    let v43 : (unit -> unit) = closure6(v2, v39)
    let v44 : unit = (fun () -> v43 (); v42) ()
    let v47 : string = v2.l0
    v47
and method40 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string) : string =
    let v9 : int32 = 1000
    let v10 : string = method41(v9)
    let v11 : int64 = v0.l0
    let v12 : string = $"{v6} {v7} #{v11} %s{v8} / {v10}"
    method22(v12)
and closure29 () () : unit =
    let v0 : US0 = US0_0
    let v1 : bool = method10(v0)
    if v1 then
        let v2 : unit = ()
        let v3 : (unit -> unit) = closure0()
        let v4 : unit = (fun () -> v3 (); v2) ()
        let struct (v18 : Mut0, v19 : Mut1, v20 : Mut2, v21 : Mut3, v22 : Mut4, v23 : int64 option) = TraceState.trace_state.Value
        let v36 : string = method11(v18, v19, v20, v21, v22, v23)
        let v37 : string = method39()
        let v38 : string = "async.run_with_timeout_async"
        let v39 : bool = v38 = ""
        let v42 : string =
            if v39 then
                let v40 : string = ""
                v40
            else
                method40(v18, v19, v20, v21, v22, v23, v36, v37, v38)
        method23(v42)
and method42 () : string =
    
    
    
    
    
    let v0 : string = "Critical"
    let v1 : (unit -> string) = v0.ToLower
    let v2 : string = v1 ()
    let v5 : char = v2.[int 0]
    let v6 : string = method16(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 = method18()
    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 = method18()
    let v101 : string = v99 + v6 
    let v102 : string = v101 + v100 
    let _v7 = v102 
    #endif
#else
    let v103 : string = "\u001b[91m"
    let v104 : string = method18()
    let v105 : string = v103 + v6 
    let v106 : string = v105 + v104 
    let _v7 = v106 
    #endif
    let v107 : string = _v7 
    v107
and method44 (v0 : int32, v1 : string) : string =
    let v2 : string = method17()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure6(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "timeout"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure6(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure6(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure6(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure6(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "ex"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure6(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure6(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure6(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure6(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method43 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : string) : string =
    let v10 : int32 = 1000
    let v11 : string = method44(v10, v9)
    let v12 : int64 = v0.l0
    let v13 : string = $"{v6} {v7} #{v12} %s{v8} / {v11}"
    method22(v13)
and closure30 (v0 : exn) () : unit =
    let v1 : US0 = US0_4
    let v2 : bool = method10(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure0()
        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 = method11(v19, v20, v21, v22, v23, v24)
        let v38 : string = method42()
        let v39 : string = $"async.run_with_timeout_async**"
        let v40 : bool = v39 = ""
        let v65 : string =
            if v40 then
                let v41 : string = ""
                v41
            else
                let v42 : unit = ()
                
#if FABLE_COMPILER || WASM || CONTRACT
                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                let v43 : string = $"%A{v0}"
                let _v42 = v43 
                #endif
#if FABLE_COMPILER_RUST && WASM
                let v46 : string = $"%A{v0}"
                let _v42 = v46 
                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                let v49 : string = $"%A{v0}"
                let _v42 = v49 
                #endif
#if FABLE_COMPILER_TYPESCRIPT
                let v52 : string = $"%A{v0}"
                let _v42 = v52 
                #endif
#if FABLE_COMPILER_PYTHON
                let v55 : string = $"%A{v0}"
                let _v42 = v55 
                #endif
#else
                let v58 : string = $"{v0.GetType ()}: {v0.Message}"
                let _v42 = v58 
                #endif
                let v59 : string = _v42 
                method43(v19, v20, v21, v22, v23, v24, v37, v38, v39, v59)
        method23(v65)
and method46 (v0 : int64, v1 : string) : string =
    let v2 : string = method17()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure6(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "retry"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure6(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure6(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure6(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure6(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "ex"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure6(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure6(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure6(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure6(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method45 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string, v9 : int64, v10 : string) : string =
    let v11 : string = method46(v9, v10)
    let v12 : int64 = v0.l0
    let v13 : string = $"{v6} {v7} #{v12} %s{v8} / {v11}"
    method22(v13)
and closure31 (v0 : int64, v1 : string) () : unit =
    let v2 : US0 = US0_1
    let v3 : bool = method10(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure0()
        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 = method11(v20, v21, v22, v23, v24, v25)
        let v39 : string = method15()
        let v40 : string = "read_all_text_retry_async"
        let v41 : bool = v40 = ""
        let v44 : string =
            if v41 then
                let v42 : string = ""
                v42
            else
                method45(v20, v21, v22, v23, v24, v25, v38, v39, v40, v0, v1)
        method23(v44)
and method38 (v0 : string, v1 : int64) : Async<string option> =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : Async<string option> = null |> unbox<Async<string option>>
    let _v2 = v3 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : Async<string option> = null |> unbox<Async<string option>>
    let _v2 = v6 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v9 : Async<string option> = null |> unbox<Async<string option>>
    let _v2 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v12 : Async<string option> = null |> unbox<Async<string option>>
    let _v2 = v12 
    #endif
#if FABLE_COMPILER_PYTHON
    let v15 : Async<string option> = null |> unbox<Async<string option>>
    let _v2 = v15 
    #endif
#else
    let v18 : Async<string option> option = None
    let mutable _v18 = v18 
    async {
    try
    let v19 : bool = v1 > 0L
    if v19 then
        let v20 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v21 : Async<int64> = null |> unbox<Async<int64>>
        let _v20 = v21 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v24 : Async<int64> = null |> unbox<Async<int64>>
        let _v20 = v24 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v27 : Async<int64> = null |> unbox<Async<int64>>
        let _v20 = v27 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v30 : Async<int64> = null |> unbox<Async<int64>>
        let _v20 = v30 
        #endif
#if FABLE_COMPILER_PYTHON
        let v33 : Async<int64> = null |> unbox<Async<int64>>
        let _v20 = v33 
        #endif
#else
        let v36 : int64 = 0L
        let v37 : Async<int64> = method27(v0, v36)
        let _v20 = v37 
        #endif
        let v38 : Async<int64> = _v20 
        let v43 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v44 : Async<US3> = null |> unbox<Async<US3>>
        let _v43 = v44 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v47 : Async<US3> = null |> unbox<Async<US3>>
        let _v43 = v47 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v50 : Async<US3> = null |> unbox<Async<US3>>
        let _v43 = v50 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v53 : Async<US3> = null |> unbox<Async<US3>>
        let _v43 = v53 
        #endif
#if FABLE_COMPILER_PYTHON
        let v56 : Async<US3> = null |> unbox<Async<US3>>
        let _v43 = v56 
        #endif
#else
        let v59 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v60 : Async<US3> = null |> unbox<Async<US3>>
        let _v59 = v60 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v63 : Async<US3> = null |> unbox<Async<US3>>
        let _v59 = v63 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v66 : Async<US3> = null |> unbox<Async<US3>>
        let _v59 = v66 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v69 : Async<US3> = null |> unbox<Async<US3>>
        let _v59 = v69 
        #endif
#if FABLE_COMPILER_PYTHON
        let v72 : Async<US3> = null |> unbox<Async<US3>>
        let _v59 = v72 
        #endif
#else
        let v75 : Async<US3> option = None
        let mutable _v75 = v75 
        async {
        let v76 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v77 : Async<Async<int64>> = null |> unbox<Async<Async<int64>>>
        let _v76 = v77 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v80 : Async<Async<int64>> = null |> unbox<Async<Async<int64>>>
        let _v76 = v80 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v83 : Async<Async<int64>> = null |> unbox<Async<Async<int64>>>
        let _v76 = v83 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v86 : Async<Async<int64>> = null |> unbox<Async<Async<int64>>>
        let _v76 = v86 
        #endif
#if FABLE_COMPILER_PYTHON
        let v89 : Async<Async<int64>> = null |> unbox<Async<Async<int64>>>
        let _v76 = v89 
        #endif
#else
        let v92 : Async<Async<int64>> = Async.StartChild (v38, 1000)
        let _v76 = v92 
        #endif
        let v93 : Async<Async<int64>> = _v76 
        let! v93 = v93 
        let v98 : Async<int64> = v93 
        let v99 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v100 : Async<Choice<int64, exn>> = null |> unbox<Async<Choice<int64, exn>>>
        let _v99 = v100 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v103 : Async<Choice<int64, exn>> = null |> unbox<Async<Choice<int64, exn>>>
        let _v99 = v103 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v106 : Async<Choice<int64, exn>> = null |> unbox<Async<Choice<int64, exn>>>
        let _v99 = v106 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v109 : Async<Choice<int64, exn>> = null |> unbox<Async<Choice<int64, exn>>>
        let _v99 = v109 
        #endif
#if FABLE_COMPILER_PYTHON
        let v112 : Async<Choice<int64, exn>> = null |> unbox<Async<Choice<int64, exn>>>
        let _v99 = v112 
        #endif
#else
        let v115 : (Async<int64> -> Async<Choice<int64, exn>>) = Async.Catch
        let v116 : Async<Choice<int64, exn>> = v115 v98
        let _v99 = v116 
        #endif
        let v117 : Async<Choice<int64, exn>> = _v99 
        let v122 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v123 : Async<US9> = null |> unbox<Async<US9>>
        let _v122 = v123 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v126 : Async<US9> = null |> unbox<Async<US9>>
        let _v122 = v126 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v129 : Async<US9> = null |> unbox<Async<US9>>
        let _v122 = v129 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v132 : Async<US9> = null |> unbox<Async<US9>>
        let _v122 = v132 
        #endif
#if FABLE_COMPILER_PYTHON
        let v135 : Async<US9> = null |> unbox<Async<US9>>
        let _v122 = v135 
        #endif
#else
        let v138 : Async<US9> option = None
        let mutable _v138 = v138 
        async {
        let! v117 = v117 
        let v139 : Choice<int64, exn> = v117 
        let v140 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v141 : US9 = null |> unbox<US9>
        let _v140 = v141 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v144 : US9 = null |> unbox<US9>
        let _v140 = v144 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v147 : US9 = null |> unbox<US9>
        let _v140 = v147 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v150 : US9 = null |> unbox<US9>
        let _v140 = v150 
        #endif
#if FABLE_COMPILER_PYTHON
        let v153 : US9 = null |> unbox<US9>
        let _v140 = v153 
        #endif
#else
        let v156 : (int64 -> US9) = closure27()
        let v157 : (exn -> US9) = closure28()
        let v158 : US9 = match v139 with Choice1Of2 x -> v156 x | Choice2Of2 x -> v157 x
        let _v140 = v158 
        #endif
        let v159 : US9 = _v140 
        return v159 
        }
        |> fun x -> _v138 <- Some x
        let v164 : Async<US9> = match _v138 with Some x -> x | None -> failwith "async.new_async_unit / _v138=None"
        let _v122 = v164 
        #endif
        let v165 : Async<US9> = _v122 
        let v170 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v171 : Async<US10> = null |> unbox<Async<US10>>
        let _v170 = v171 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v174 : Async<US10> = null |> unbox<Async<US10>>
        let _v170 = v174 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v177 : Async<US10> = null |> unbox<Async<US10>>
        let _v170 = v177 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v180 : Async<US10> = null |> unbox<Async<US10>>
        let _v170 = v180 
        #endif
#if FABLE_COMPILER_PYTHON
        let v183 : Async<US10> = null |> unbox<Async<US10>>
        let _v170 = v183 
        #endif
#else
        let v186 : Async<US10> option = None
        let mutable _v186 = v186 
        async {
        let! v165 = v165 
        let v187 : US9 = v165 
        let v193 : US10 =
            match v187 with
            | US9_0(v188) -> (* C1of2 *)
                US10_0(v188)
            | US9_1(v190) -> (* C2of2 *)
                US10_1(v190)
        return v193 
        }
        |> fun x -> _v186 <- Some x
        let v194 : Async<US10> = match _v186 with Some x -> x | None -> failwith "async.new_async_unit / _v186=None"
        let _v170 = v194 
        #endif
        let v195 : Async<US10> = _v170 
        let v200 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v201 : Async<US3> = null |> unbox<Async<US3>>
        let _v200 = v201 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v204 : Async<US3> = null |> unbox<Async<US3>>
        let _v200 = v204 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v207 : Async<US3> = null |> unbox<Async<US3>>
        let _v200 = v207 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v210 : Async<US3> = null |> unbox<Async<US3>>
        let _v200 = v210 
        #endif
#if FABLE_COMPILER_PYTHON
        let v213 : Async<US3> = null |> unbox<Async<US3>>
        let _v200 = v213 
        #endif
#else
        let v216 : Async<US3> option = None
        let mutable _v216 = v216 
        async {
        let! v195 = v195 
        let v217 : US10 = v195 
        let v346 : US3 =
            match v217 with
            | US10_1(v220) -> (* Error *)
                let v221 : string = $"%A{v220}"
                let v224 : string = "System.TimeoutException"
                let v225 : bool = v221.Contains v224 
                if v225 then
                    let v228 : unit = ()
                    let v229 : (unit -> unit) = closure29()
                    let v230 : unit = (fun () -> v229 (); v228) ()
                    US3_1
                else
                    let v275 : unit = ()
                    let v276 : (unit -> unit) = closure30(v220)
                    let v277 : unit = (fun () -> v276 (); v275) ()
                    US3_1
            | US10_0(v218) -> (* Ok *)
                US3_0(v218)
        return v346 
        }
        |> fun x -> _v216 <- Some x
        let v347 : Async<US3> = match _v216 with Some x -> x | None -> failwith "async.new_async_unit / _v216=None"
        let _v200 = v347 
        #endif
        let v348 : Async<US3> = _v200 
        return! v348 
        }
        |> fun x -> _v75 <- Some x
        let v353 : Async<US3> = match _v75 with Some x -> x | None -> failwith "async.new_async_unit / _v75=None"
        let _v59 = v353 
        #endif
        let v354 : Async<US3> = _v59 
        let _v43 = v354 
        #endif
        let v359 : Async<US3> = _v43 
        let v364 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v365 : Async<unit> = null |> unbox<Async<unit>>
        let _v364 = v365 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v368 : Async<unit> = null |> unbox<Async<unit>>
        let _v364 = v368 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v371 : Async<unit> = null |> unbox<Async<unit>>
        let _v364 = v371 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v374 : Async<unit> = null |> unbox<Async<unit>>
        let _v364 = v374 
        #endif
#if FABLE_COMPILER_PYTHON
        let v377 : Async<unit> = null |> unbox<Async<unit>>
        let _v364 = v377 
        #endif
#else
        let v380 : (Async<US3> -> Async<unit>) = Async.Ignore
        let v381 : Async<unit> = v380 v359
        let _v364 = v381 
        #endif
        let v382 : Async<unit> = _v364 
        do! v382 
        ()
    let v387 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v388 : Async<string> = null |> unbox<Async<string>>
    let _v387 = v388 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v391 : Async<string> = null |> unbox<Async<string>>
    let _v387 = v391 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v394 : Async<string> = null |> unbox<Async<string>>
    let _v387 = v394 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v397 : Async<string> = null |> unbox<Async<string>>
    let _v387 = v397 
    #endif
#if FABLE_COMPILER_PYTHON
    let v400 : Async<string> = null |> unbox<Async<string>>
    let _v387 = v400 
    #endif
#else
    let v403 : (string -> System.Threading.Tasks.Task<string>) = System.IO.File.ReadAllTextAsync
    let v404 : System.Threading.Tasks.Task<string> = v403 v0
    let v405 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v406 : Async<string> = null |> unbox<Async<string>>
    let _v405 = v406 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v409 : Async<string> = null |> unbox<Async<string>>
    let _v405 = v409 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v412 : Async<string> = null |> unbox<Async<string>>
    let _v405 = v412 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v415 : Async<string> = null |> unbox<Async<string>>
    let _v405 = v415 
    #endif
#if FABLE_COMPILER_PYTHON
    let v418 : Async<string> = null |> unbox<Async<string>>
    let _v405 = v418 
    #endif
#else
    let v421 : (System.Threading.Tasks.Task<string> -> Async<string>) = Async.AwaitTask
    let v422 : Async<string> = v421 v404
    let _v405 = v422 
    #endif
    let v423 : Async<string> = _v405 
    let _v387 = v423 
    #endif
    let v428 : Async<string> = _v387 
    let v433 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v434 : Async<string option> = null |> unbox<Async<string option>>
    let _v433 = v434 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v437 : Async<string option> = null |> unbox<Async<string option>>
    let _v433 = v437 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v440 : Async<string option> = null |> unbox<Async<string option>>
    let _v433 = v440 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v443 : Async<string option> = null |> unbox<Async<string option>>
    let _v433 = v443 
    #endif
#if FABLE_COMPILER_PYTHON
    let v446 : Async<string option> = null |> unbox<Async<string option>>
    let _v433 = v446 
    #endif
#else
    let v449 : Async<string option> option = None
    let mutable _v449 = v449 
    async {
    let! v428 = v428 
    let v450 : string = v428 
    let v451 : string option = Some v450 
    return v451 
    }
    |> fun x -> _v449 <- Some x
    let v454 : Async<string option> = match _v449 with Some x -> x | None -> failwith "async.new_async_unit / _v449=None"
    let _v433 = v454 
    #endif
    let v455 : Async<string option> = _v433 
    return! v455 
    with ex ->
    let v460 : exn = ex
    let v461 : bool = v1 = 0L
    let v462 : bool = v461 <> true
    if v462 then
        let v463 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v464 : string = $"%A{v460}"
        let _v463 = v464 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v467 : string = $"%A{v460}"
        let _v463 = v467 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v470 : string = $"%A{v460}"
        let _v463 = v470 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v473 : string = $"%A{v460}"
        let _v463 = v473 
        #endif
#if FABLE_COMPILER_PYTHON
        let v476 : string = $"%A{v460}"
        let _v463 = v476 
        #endif
#else
        let v479 : string = $"{v460.GetType ()}: {v460.Message}"
        let _v463 = v479 
        #endif
        let v480 : string = _v463 
        let v485 : unit = ()
        let v486 : (unit -> unit) = closure31(v1, v480)
        let v487 : unit = (fun () -> v486 (); v485) ()
        let v531 : string option = None
        return v531 
        (*
        ()
    else
        *) else
        let v532 : int64 = v1 + 1L
        let v533 : Async<string option> = method38(v0, v532)
        return! v533 
        (*
        ()
    *)
    (*
    let v534 : string option = *)
    }
    |> fun x -> _v18 <- Some x
    let v535 : Async<string option> = match _v18 with Some x -> x | None -> failwith "async.new_async_unit / _v18=None"
    let _v2 = v535 
    #endif
    let v536 : Async<string option> = _v2 
    v536
and closure26 () (v0 : string) : Async<string option> =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : Async<string option> = null |> unbox<Async<string option>>
    let _v1 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : Async<string option> = null |> unbox<Async<string option>>
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : Async<string option> = null |> unbox<Async<string option>>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v11 : Async<string option> = null |> unbox<Async<string option>>
    let _v1 = v11 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : Async<string option> = null |> unbox<Async<string option>>
    let _v1 = v14 
    #endif
#else
    let v17 : int64 = 0L
    let v18 : Async<string option> = method38(v0, v17)
    let _v1 = v18 
    #endif
    let v19 : Async<string option> = _v1 
    v19
and closure33 () (v0 : chrono_DateTime<chrono_Utc>) : US11 =
    US11_0(v0)
and method49 () : (chrono_DateTime<chrono_Utc> -> US11) =
    closure33()
and method50 () : string =
    let v0 : string = "hh:mm"
    v0
and method51 () : string =
    let v0 : string = "yyyyMMdd-HHmm-ssff-ffff-f"
    v0
and method52 () : string =
    let v0 : string = "hhmm"
    v0
and method48 (v0 : System.Guid, v1 : System.DateTime) : System.Guid =
    let v2 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v3 : System.DateTime = System.DateTime (1970, 1, 1, 0, 0, 0, System.DateTimeKind.Utc)
    let v6 : (System.DateTime -> System.DateTime) = _.ToUniversalTime()
    let v7 : System.DateTime = v6 v3
    let v10 : System.DateTimeKind = System.DateTimeKind.Local
    let v11 : System.DateTime = System.DateTime.SpecifyKind (v1, v10)
    let v12 : (System.DateTime -> System.DateTime) = _.ToUniversalTime()
    let v13 : System.DateTime = v12 v11
    let v16 : (System.DateTime -> int64) = _.Ticks
    let v17 : int64 = v16 v13
    let v20 : (System.DateTime -> int64) = _.Ticks
    let v21 : int64 = v20 v7
    let v24 : int64 = v17 - v21
    let v25 : int64 = v24 / 10L
    let v26 : string = "chrono::DateTime::from_timestamp_micros($0)"
    let v27 : chrono_DateTime<chrono_Utc> option = Fable.Core.RustInterop.emitRustExpr v25 v26 
    let v28 : (chrono_DateTime<chrono_Utc> -> US11) = method49()
    let v29 : US11 option = v27 |> Option.map v28 
    let v40 : US11 = US11_1
    let v41 : US11 = v29 |> Option.defaultValue v40 
    let v61 : US1 =
        match v41 with
        | US11_1 -> (* None *)
            US1_1
        | US11_0(v45) -> (* Some *)
            let v46 : string = "$0.naive_utc()"
            let v47 : chrono_NaiveDateTime = Fable.Core.RustInterop.emitRustExpr v45 v46 
            let v48 : string = "chrono::offset::TimeZone::from_utc_datetime(&chrono::Local, &$0)"
            let v49 : chrono_DateTime<chrono_Local> = Fable.Core.RustInterop.emitRustExpr v47 v48 
            let v50 : string = "%Y%m%d-%H%M-%S%f"
            let v51 : string = "r#\"" + v50 + "\"#"
            let v52 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v51 
            let v53 : string = "$0.format($1).to_string()"
            let v54 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v49, v52) v53 
            let v55 : string = "fable_library_rust::String_::fromString($0)"
            let v56 : string = Fable.Core.RustInterop.emitRustExpr v54 v55 
            let v57 : string = $"{v56.[0..17]}-{v56.[18..21]}-{v56.[22]}"
            US1_0(v57)
    let v65 : string =
        match v61 with
        | US1_1 -> (* None *)
            let v63 : string = ""
            v63
        | US1_0(v62) -> (* Some *)
            v62
    let v66 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v67 : string = "0i64.into()"
    let v68 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v67 
    let _v66 = v68 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v69 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v66 = v69 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v72 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v66 = v72 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v75 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v66 = v75 
    #endif
#if FABLE_COMPILER_PYTHON
    let v78 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v66 = v78 
    #endif
#else
    let v81 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v66 = v81 
    #endif
    let v82 : System.TimeZoneInfo = _v66 
    let v87 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v88 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v89 : System.TimeSpan = v88 ()
    let _v87 = v89 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v92 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v93 : System.TimeSpan = v92 ()
    let _v87 = v93 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v96 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v97 : System.TimeSpan = v96 ()
    let _v87 = v97 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v100 : US4 = US4_0
    let v101 : US5 = US5_3(v100)
    let v102 : string = $"date_time.get_utc_offset / target: {v101}"
    let v103 : System.TimeSpan = failwith<System.TimeSpan> v102
    let _v87 = v103 
    #endif
#if FABLE_COMPILER_PYTHON
    let v104 : US4 = US4_0
    let v105 : US5 = US5_4(v104)
    let v106 : string = $"date_time.get_utc_offset / target: {v105}"
    let v107 : System.TimeSpan = failwith<System.TimeSpan> v106
    let _v87 = v107 
    #endif
#else
    let v108 : (System.TimeZoneInfo -> (System.DateTime -> System.TimeSpan)) = _.GetUtcOffset
    let v109 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v110 : string = "0i64.into()"
    let v111 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v110 
    let _v109 = v111 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v112 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v109 = v112 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v115 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v109 = v115 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v118 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v109 = v118 
    #endif
#if FABLE_COMPILER_PYTHON
    let v121 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v109 = v121 
    #endif
#else
    let v124 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v109 = v124 
    #endif
    let v125 : System.TimeZoneInfo = _v109 
    let v130 : (System.DateTime -> System.TimeSpan) = v108 v125
    let v131 : System.TimeSpan = v130 v13
    let _v87 = v131 
    #endif
    let v132 : System.TimeSpan = _v87 
    let v138 : (System.TimeSpan -> int32) = _.Hours
    let v139 : int32 = v138 v132
    let v142 : bool = v139 > 0
    let v143 : uint8 =
        if v142 then
            1uy
        else
            0uy
    let v144 : string = method50()
    let v145 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v146 : string = v132.ToString v144 
    let _v145 = v146 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v147 : string = v132.ToString v144 
    let _v145 = v147 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v148 : string = v132.ToString v144 
    let _v145 = v148 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v149 : string = v132.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v145 = v149 
    #endif
#if FABLE_COMPILER_PYTHON
    let v150 : string = v132.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v145 = v150 
    #endif
#else
    let v151 : string = v132.ToString v144 
    let _v145 = v151 
    #endif
    let v152 : string = _v145 
    let v155 : string = $"{v143}{v152.[0..1]}{v152.[3..4]}"
    let v156 : (System.Guid -> string) = _.ToString()
    let v157 : string = v156 v0
    let v160 : System.Guid = System.Guid $"{v65}{v155}{v157.[v65.Length + v155.Length..]}"
    let _v2 = v160 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v161 : System.DateTime = System.DateTime (1970, 1, 1, 0, 0, 0, System.DateTimeKind.Utc)
    let v164 : (System.DateTime -> System.DateTime) = _.ToUniversalTime()
    let v165 : System.DateTime = v164 v161
    let v168 : System.DateTimeKind = System.DateTimeKind.Local
    let v169 : System.DateTime = System.DateTime.SpecifyKind (v1, v168)
    let v170 : (System.DateTime -> System.DateTime) = _.ToUniversalTime()
    let v171 : System.DateTime = v170 v169
    let v174 : (System.DateTime -> int64) = _.Ticks
    let v175 : int64 = v174 v171
    let v178 : (System.DateTime -> int64) = _.Ticks
    let v179 : int64 = v178 v165
    let v182 : int64 = v175 - v179
    let v183 : int64 = v182 / 10L
    let v184 : string = "chrono::DateTime::from_timestamp_micros($0)"
    let v185 : chrono_DateTime<chrono_Utc> option = Fable.Core.RustInterop.emitRustExpr v183 v184 
    let v186 : (chrono_DateTime<chrono_Utc> -> US11) = method49()
    let v187 : US11 option = v185 |> Option.map v186 
    let v198 : US11 = US11_1
    let v199 : US11 = v187 |> Option.defaultValue v198 
    let v219 : US1 =
        match v199 with
        | US11_1 -> (* None *)
            US1_1
        | US11_0(v203) -> (* Some *)
            let v204 : string = "$0.naive_utc()"
            let v205 : chrono_NaiveDateTime = Fable.Core.RustInterop.emitRustExpr v203 v204 
            let v206 : string = "chrono::offset::TimeZone::from_utc_datetime(&chrono::Local, &$0)"
            let v207 : chrono_DateTime<chrono_Local> = Fable.Core.RustInterop.emitRustExpr v205 v206 
            let v208 : string = "%Y%m%d-%H%M-%S%f"
            let v209 : string = "r#\"" + v208 + "\"#"
            let v210 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr () v209 
            let v211 : string = "$0.format($1).to_string()"
            let v212 : std_string_String = Fable.Core.RustInterop.emitRustExpr struct (v207, v210) v211 
            let v213 : string = "fable_library_rust::String_::fromString($0)"
            let v214 : string = Fable.Core.RustInterop.emitRustExpr v212 v213 
            let v215 : string = $"{v214.[0..17]}-{v214.[18..21]}-{v214.[22]}"
            US1_0(v215)
    let v223 : string =
        match v219 with
        | US1_1 -> (* None *)
            let v221 : string = ""
            v221
        | US1_0(v220) -> (* Some *)
            v220
    let v224 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v225 : string = "0i64.into()"
    let v226 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v225 
    let _v224 = v226 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v227 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v224 = v227 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v230 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v224 = v230 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v233 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v224 = v233 
    #endif
#if FABLE_COMPILER_PYTHON
    let v236 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v224 = v236 
    #endif
#else
    let v239 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v224 = v239 
    #endif
    let v240 : System.TimeZoneInfo = _v224 
    let v245 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v246 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v247 : System.TimeSpan = v246 ()
    let _v245 = v247 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v250 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v251 : System.TimeSpan = v250 ()
    let _v245 = v251 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v254 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v255 : System.TimeSpan = v254 ()
    let _v245 = v255 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v258 : US4 = US4_0
    let v259 : US5 = US5_3(v258)
    let v260 : string = $"date_time.get_utc_offset / target: {v259}"
    let v261 : System.TimeSpan = failwith<System.TimeSpan> v260
    let _v245 = v261 
    #endif
#if FABLE_COMPILER_PYTHON
    let v262 : US4 = US4_0
    let v263 : US5 = US5_4(v262)
    let v264 : string = $"date_time.get_utc_offset / target: {v263}"
    let v265 : System.TimeSpan = failwith<System.TimeSpan> v264
    let _v245 = v265 
    #endif
#else
    let v266 : (System.TimeZoneInfo -> (System.DateTime -> System.TimeSpan)) = _.GetUtcOffset
    let v267 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v268 : string = "0i64.into()"
    let v269 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v268 
    let _v267 = v269 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v270 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v267 = v270 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v273 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v267 = v273 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v276 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v267 = v276 
    #endif
#if FABLE_COMPILER_PYTHON
    let v279 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v267 = v279 
    #endif
#else
    let v282 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v267 = v282 
    #endif
    let v283 : System.TimeZoneInfo = _v267 
    let v288 : (System.DateTime -> System.TimeSpan) = v266 v283
    let v289 : System.TimeSpan = v288 v171
    let _v245 = v289 
    #endif
    let v290 : System.TimeSpan = _v245 
    let v296 : (System.TimeSpan -> int32) = _.Hours
    let v297 : int32 = v296 v290
    let v300 : bool = v297 > 0
    let v301 : uint8 =
        if v300 then
            1uy
        else
            0uy
    let v302 : string = method50()
    let v303 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v304 : string = v290.ToString v302 
    let _v303 = v304 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v305 : string = v290.ToString v302 
    let _v303 = v305 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v306 : string = v290.ToString v302 
    let _v303 = v306 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v307 : string = v290.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v303 = v307 
    #endif
#if FABLE_COMPILER_PYTHON
    let v308 : string = v290.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v303 = v308 
    #endif
#else
    let v309 : string = v290.ToString v302 
    let _v303 = v309 
    #endif
    let v310 : string = _v303 
    let v313 : string = $"{v301}{v310.[0..1]}{v310.[3..4]}"
    let v314 : (System.Guid -> string) = _.ToString()
    let v315 : string = v314 v0
    let v318 : System.Guid = System.Guid $"{v223}{v313}{v315.[v223.Length + v313.Length..]}"
    let _v2 = v318 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v319 : System.Guid = null |> unbox<System.Guid>
    let _v2 = v319 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v322 : string = method51()
    let v323 : (string -> string) = v1.ToString
    let v324 : string = v323 v322
    let v327 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v328 : string = "0i64.into()"
    let v329 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v328 
    let _v327 = v329 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v330 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v327 = v330 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v333 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v327 = v333 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v336 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v327 = v336 
    #endif
#if FABLE_COMPILER_PYTHON
    let v339 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v327 = v339 
    #endif
#else
    let v342 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v327 = v342 
    #endif
    let v343 : System.TimeZoneInfo = _v327 
    let v348 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v349 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v350 : System.TimeSpan = v349 ()
    let _v348 = v350 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v353 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v354 : System.TimeSpan = v353 ()
    let _v348 = v354 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v357 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v358 : System.TimeSpan = v357 ()
    let _v348 = v358 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v361 : US4 = US4_0
    let v362 : US5 = US5_3(v361)
    let v363 : string = $"date_time.get_utc_offset / target: {v362}"
    let v364 : System.TimeSpan = failwith<System.TimeSpan> v363
    let _v348 = v364 
    #endif
#if FABLE_COMPILER_PYTHON
    let v365 : US4 = US4_0
    let v366 : US5 = US5_4(v365)
    let v367 : string = $"date_time.get_utc_offset / target: {v366}"
    let v368 : System.TimeSpan = failwith<System.TimeSpan> v367
    let _v348 = v368 
    #endif
#else
    let v369 : (System.TimeZoneInfo -> (System.DateTime -> System.TimeSpan)) = _.GetUtcOffset
    let v370 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v371 : string = "0i64.into()"
    let v372 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v371 
    let _v370 = v372 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v373 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v370 = v373 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v376 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v370 = v376 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v379 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v370 = v379 
    #endif
#if FABLE_COMPILER_PYTHON
    let v382 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v370 = v382 
    #endif
#else
    let v385 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v370 = v385 
    #endif
    let v386 : System.TimeZoneInfo = _v370 
    let v391 : (System.DateTime -> System.TimeSpan) = v369 v386
    let v392 : System.TimeSpan = v391 v1
    let _v348 = v392 
    #endif
    let v393 : System.TimeSpan = _v348 
    let v399 : (System.TimeSpan -> int32) = _.Hours
    let v400 : int32 = v399 v393
    let v403 : bool = v400 > 0
    let v404 : uint8 =
        if v403 then
            1uy
        else
            0uy
    let v405 : string = method52()
    let v406 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v407 : string = v393.ToString v405 
    let _v406 = v407 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v408 : string = v393.ToString v405 
    let _v406 = v408 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v409 : string = v393.ToString v405 
    let _v406 = v409 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v410 : string = v393.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v406 = v410 
    #endif
#if FABLE_COMPILER_PYTHON
    let v411 : string = v393.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v406 = v411 
    #endif
#else
    let v412 : string = v393.ToString v405 
    let _v406 = v412 
    #endif
    let v413 : string = _v406 
    let v416 : string = $"{v404}{v413}"
    let v417 : (System.Guid -> string) = _.ToString()
    let v418 : string = v417 v0
    let v421 : System.Guid = System.Guid $"{v324}{v416}{v418.[v324.Length + v416.Length..]}"
    let _v2 = v421 
    #endif
#if FABLE_COMPILER_PYTHON
    let v422 : string = method51()
    let v423 : (string -> string) = v1.ToString
    let v424 : string = v423 v422
    let v427 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v428 : string = "0i64.into()"
    let v429 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v428 
    let _v427 = v429 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v430 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v427 = v430 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v433 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v427 = v433 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v436 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v427 = v436 
    #endif
#if FABLE_COMPILER_PYTHON
    let v439 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v427 = v439 
    #endif
#else
    let v442 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v427 = v442 
    #endif
    let v443 : System.TimeZoneInfo = _v427 
    let v448 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v449 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v450 : System.TimeSpan = v449 ()
    let _v448 = v450 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v453 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v454 : System.TimeSpan = v453 ()
    let _v448 = v454 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v457 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v458 : System.TimeSpan = v457 ()
    let _v448 = v458 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v461 : US4 = US4_0
    let v462 : US5 = US5_3(v461)
    let v463 : string = $"date_time.get_utc_offset / target: {v462}"
    let v464 : System.TimeSpan = failwith<System.TimeSpan> v463
    let _v448 = v464 
    #endif
#if FABLE_COMPILER_PYTHON
    let v465 : US4 = US4_0
    let v466 : US5 = US5_4(v465)
    let v467 : string = $"date_time.get_utc_offset / target: {v466}"
    let v468 : System.TimeSpan = failwith<System.TimeSpan> v467
    let _v448 = v468 
    #endif
#else
    let v469 : (System.TimeZoneInfo -> (System.DateTime -> System.TimeSpan)) = _.GetUtcOffset
    let v470 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v471 : string = "0i64.into()"
    let v472 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v471 
    let _v470 = v472 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v473 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v470 = v473 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v476 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v470 = v476 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v479 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v470 = v479 
    #endif
#if FABLE_COMPILER_PYTHON
    let v482 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v470 = v482 
    #endif
#else
    let v485 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v470 = v485 
    #endif
    let v486 : System.TimeZoneInfo = _v470 
    let v491 : (System.DateTime -> System.TimeSpan) = v469 v486
    let v492 : System.TimeSpan = v491 v1
    let _v448 = v492 
    #endif
    let v493 : System.TimeSpan = _v448 
    let v499 : (System.TimeSpan -> int32) = _.Hours
    let v500 : int32 = v499 v493
    let v503 : bool = v500 > 0
    let v504 : uint8 =
        if v503 then
            1uy
        else
            0uy
    let v505 : string = method52()
    let v506 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v507 : string = v493.ToString v505 
    let _v506 = v507 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v508 : string = v493.ToString v505 
    let _v506 = v508 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v509 : string = v493.ToString v505 
    let _v506 = v509 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v510 : string = v493.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v506 = v510 
    #endif
#if FABLE_COMPILER_PYTHON
    let v511 : string = v493.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v506 = v511 
    #endif
#else
    let v512 : string = v493.ToString v505 
    let _v506 = v512 
    #endif
    let v513 : string = _v506 
    let v516 : string = $"{v504}{v513}"
    let v517 : (System.Guid -> string) = _.ToString()
    let v518 : string = v517 v0
    let v521 : System.Guid = System.Guid $"{v424}{v516}{v518.[v424.Length + v516.Length..]}"
    let _v2 = v521 
    #endif
#else
    let v522 : string = method51()
    let v523 : (string -> string) = v1.ToString
    let v524 : string = v523 v522
    let v527 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v528 : string = "0i64.into()"
    let v529 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v528 
    let _v527 = v529 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v530 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v527 = v530 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v533 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v527 = v533 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v536 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v527 = v536 
    #endif
#if FABLE_COMPILER_PYTHON
    let v539 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v527 = v539 
    #endif
#else
    let v542 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v527 = v542 
    #endif
    let v543 : System.TimeZoneInfo = _v527 
    let v548 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v549 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v550 : System.TimeSpan = v549 ()
    let _v548 = v550 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v553 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v554 : System.TimeSpan = v553 ()
    let _v548 = v554 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v557 : (unit -> System.TimeSpan) = System.TimeSpan 
    let v558 : System.TimeSpan = v557 ()
    let _v548 = v558 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v561 : US4 = US4_0
    let v562 : US5 = US5_3(v561)
    let v563 : string = $"date_time.get_utc_offset / target: {v562}"
    let v564 : System.TimeSpan = failwith<System.TimeSpan> v563
    let _v548 = v564 
    #endif
#if FABLE_COMPILER_PYTHON
    let v565 : US4 = US4_0
    let v566 : US5 = US5_4(v565)
    let v567 : string = $"date_time.get_utc_offset / target: {v566}"
    let v568 : System.TimeSpan = failwith<System.TimeSpan> v567
    let _v548 = v568 
    #endif
#else
    let v569 : (System.TimeZoneInfo -> (System.DateTime -> System.TimeSpan)) = _.GetUtcOffset
    let v570 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v571 : string = "0i64.into()"
    let v572 : System.TimeZoneInfo = Fable.Core.RustInterop.emitRustExpr () v571 
    let _v570 = v572 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v573 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v570 = v573 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v576 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v570 = v576 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v579 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v570 = v579 
    #endif
#if FABLE_COMPILER_PYTHON
    let v582 : System.TimeZoneInfo = null |> unbox<System.TimeZoneInfo>
    let _v570 = v582 
    #endif
#else
    let v585 : System.TimeZoneInfo = System.TimeZoneInfo.Local
    let _v570 = v585 
    #endif
    let v586 : System.TimeZoneInfo = _v570 
    let v591 : (System.DateTime -> System.TimeSpan) = v569 v586
    let v592 : System.TimeSpan = v591 v1
    let _v548 = v592 
    #endif
    let v593 : System.TimeSpan = _v548 
    let v599 : (System.TimeSpan -> int32) = _.Hours
    let v600 : int32 = v599 v593
    let v603 : bool = v600 > 0
    let v604 : uint8 =
        if v603 then
            1uy
        else
            0uy
    let v605 : string = method52()
    let v606 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v607 : string = v593.ToString v605 
    let _v606 = v607 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v608 : string = v593.ToString v605 
    let _v606 = v608 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v609 : string = v593.ToString v605 
    let _v606 = v609 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v610 : string = v593.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v606 = v610 
    #endif
#if FABLE_COMPILER_PYTHON
    let v611 : string = v593.ToString ("c", System.Globalization.CultureInfo.InvariantCulture)
    let _v606 = v611 
    #endif
#else
    let v612 : string = v593.ToString v605 
    let _v606 = v612 
    #endif
    let v613 : string = _v606 
    let v616 : string = $"{v604}{v613}"
    let v617 : (System.Guid -> string) = _.ToString()
    let v618 : string = v617 v0
    let v621 : System.Guid = System.Guid $"{v524}{v616}{v618.[v524.Length + v616.Length..]}"
    let _v2 = v621 
    #endif
    let v622 : System.Guid = _v2 
    v622
and method54 () : string =
    let v0 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v1 : string = "std::env::temp_dir()"
    let v2 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr () v1 
    let v3 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v4 : string = "$0.display()"
    let v5 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2 v4 
    let _v3 = v5 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v6 : string = "$0.display()"
    let v7 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2 v6 
    let _v3 = v7 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : string = "$0.display()"
    let v9 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2 v8 
    let _v3 = v9 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v10 : std_path_Display = v2 |> unbox<std_path_Display>
    let _v3 = v10 
    #endif
#if FABLE_COMPILER_PYTHON
    let v13 : std_path_Display = v2 |> unbox<std_path_Display>
    let _v3 = v13 
    #endif
#else
    let v16 : std_path_Display = v2 |> unbox<std_path_Display>
    let _v3 = v16 
    #endif
    let v19 : std_path_Display = _v3 
    let v24 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v25 : string = "format!(\"{}\", $0)"
    let v26 : std_string_String = Fable.Core.RustInterop.emitRustExpr v19 v25 
    let _v24 = v26 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v27 : string = "format!(\"{}\", $0)"
    let v28 : std_string_String = Fable.Core.RustInterop.emitRustExpr v19 v27 
    let _v24 = v28 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v29 : string = "format!(\"{}\", $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 = null |> unbox<std_string_String>
    let _v24 = v31 
    #endif
#if FABLE_COMPILER_PYTHON
    let v34 : std_string_String = null |> unbox<std_string_String>
    let _v24 = v34 
    #endif
#else
    let v37 : std_string_String = null |> unbox<std_string_String>
    let _v24 = v37 
    #endif
    let v40 : std_string_String = _v24 
    let v45 : string = "fable_library_rust::String_::fromString($0)"
    let v46 : string = Fable.Core.RustInterop.emitRustExpr v40 v45 
    let _v0 = v46 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v47 : US4 = US4_1
    let v48 : US5 = US5_2(v47)
    let v49 : string = $"file_system.get_temp_path / target: {v48}"
    let v50 : string = failwith<string> v49
    let _v0 = v50 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v51 : string = null |> unbox<string>
    let _v0 = v51 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v54 : US4 = US4_0
    let v55 : US5 = US5_3(v54)
    let v56 : string = $"file_system.get_temp_path / target: {v55}"
    let v57 : string = failwith<string> v56
    let _v0 = v57 
    #endif
#if FABLE_COMPILER_PYTHON
    let v58 : US4 = US4_0
    let v59 : US5 = US5_4(v58)
    let v60 : string = $"file_system.get_temp_path / target: {v59}"
    let v61 : string = failwith<string> v60
    let _v0 = v61 
    #endif
#else
    let v62 : (unit -> string) = System.IO.Path.GetTempPath
    let v63 : string = v62 ()
    let _v0 = v63 
    #endif
    let v64 : string = _v0 
    v64
and method55 () : string =
    let v0 : string = "!create_temp_path_"
    v0
and method58 (v0 : string) : string =
    v0
and method57 (v0 : string, v1 : string) : struct (string * string) =
    let v2 : string = method58(v0)
    struct (v1, v2)
and method56 (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 : US4 = US4_1
    let v155 : US5 = US5_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) = method57(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 : US4 = US4_0
    let v168 : US5 = US5_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 method60 () : string =
    let v0 : string = "CARGO_PKG_NAME"
    v0
and method59 () : string =
    let v0 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v1 : string = method60()
    let v2 : string = method2(v1)
    let _v0 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v3 : string = method60()
    let v4 : string = method2(v3)
    let _v0 = v4 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v5 : string = method60()
    let v6 : string = method2(v5)
    let _v0 = v6 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v7 : US4 = US4_0
    let v8 : US5 = US5_3(v7)
    let v9 : string = $"env.get_entry_assembly_name / target: {v8}"
    let v10 : string = failwith<string> v9
    let _v0 = v10 
    #endif
#if FABLE_COMPILER_PYTHON
    let v11 : US4 = US4_0
    let v12 : US5 = US5_4(v11)
    let v13 : string = $"env.get_entry_assembly_name / target: {v12}"
    let v14 : string = failwith<string> v13
    let _v0 = v14 
    #endif
#else
    let v15 : string = System.Reflection.Assembly.GetEntryAssembly().GetName().Name
    let _v0 = v15 
    #endif
    let v16 : string = _v0 
    v16
and method53 (v0 : System.Guid) : string =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = method54()
    let v3 : string = method55()
    let v4 : string = method56(v2, v3)
    let v5 : string = method59()
    let v6 : string = method56(v4, v5)
    let v7 : (System.Guid -> string) = _.ToString()
    let v8 : string = v7 v0
    let v11 : string = method56(v6, v8)
    let _v1 = v11 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v12 : string = method54()
    let v13 : string = method55()
    let v14 : string = method56(v12, v13)
    let v15 : string = method59()
    let v16 : string = method56(v14, v15)
    let v17 : (System.Guid -> string) = _.ToString()
    let v18 : string = v17 v0
    let v21 : string = method56(v16, v18)
    let _v1 = v21 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v22 : string = null |> unbox<string>
    let _v1 = v22 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v25 : string = method54()
    let v26 : string = method55()
    let v27 : string = method56(v25, v26)
    let v28 : string = method59()
    let v29 : string = method56(v27, v28)
    let v30 : (System.Guid -> string) = _.ToString()
    let v31 : string = v30 v0
    let v34 : string = method56(v29, v31)
    let _v1 = v34 
    #endif
#if FABLE_COMPILER_PYTHON
    let v35 : string = method54()
    let v36 : string = method55()
    let v37 : string = method56(v35, v36)
    let v38 : string = method59()
    let v39 : string = method56(v37, v38)
    let v40 : (System.Guid -> string) = _.ToString()
    let v41 : string = v40 v0
    let v44 : string = method56(v39, v41)
    let _v1 = v44 
    #endif
#else
    let v45 : string = method54()
    let v46 : string = method55()
    let v47 : string = method56(v45, v46)
    let v48 : string = method59()
    let v49 : string = method56(v47, v48)
    let v50 : (System.Guid -> string) = _.ToString()
    let v51 : string = v50 v0
    let v54 : string = method56(v49, v51)
    let _v1 = v54 
    #endif
    let v55 : string = _v1 
    v55
and method47 () : string =
    let v0 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v1 : System.DateTime = System.DateTime.Now
    let v4 : (unit -> System.Guid) = System.Guid.NewGuid
    let v5 : System.Guid = v4 ()
    let v8 : System.Guid = method48(v5, v1)
    let v9 : string = method53(v8)
    let _v0 = v9 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v10 : System.DateTime = System.DateTime.Now
    let v13 : (unit -> System.Guid) = System.Guid.NewGuid
    let v14 : System.Guid = v13 ()
    let v17 : System.Guid = method48(v14, v10)
    let v18 : string = method53(v17)
    let _v0 = v18 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v19 : string = null |> unbox<string>
    let _v0 = v19 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v22 : System.DateTime = System.DateTime.Now
    let v25 : (unit -> System.Guid) = System.Guid.NewGuid
    let v26 : System.Guid = v25 ()
    let v29 : System.Guid = method48(v26, v22)
    let v30 : string = method53(v29)
    let _v0 = v30 
    #endif
#if FABLE_COMPILER_PYTHON
    let v31 : System.DateTime = System.DateTime.Now
    let v34 : (unit -> System.Guid) = System.Guid.NewGuid
    let v35 : System.Guid = v34 ()
    let v38 : System.Guid = method48(v35, v31)
    let v39 : string = method53(v38)
    let _v0 = v39 
    #endif
#else
    let v40 : System.DateTime = System.DateTime.Now
    let v43 : (unit -> System.Guid) = System.Guid.NewGuid
    let v44 : System.Guid = v43 ()
    let v47 : System.Guid = method48(v44, v40)
    let v48 : string = method53(v47)
    let _v0 = v48 
    #endif
    let v49 : string = _v0 
    v49
and closure32 () () : string =
    method47()
and method62 (v0 : string) : string =
    v0
and closure35 () (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 method63 () : (std_io_Error -> std_string_String) =
    closure35()
and closure36 () () : US12 =
    US12_0
and closure37 () (v0 : std_string_String) : US12 =
    US12_1(v0)
and method65 (v0 : string, v1 : std_string_String) : string =
    let v2 : string = method17()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure6(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "dir"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure6(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure6(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure6(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure6(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "error"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure6(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure6(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v66 : string = "format!(\"{:#?}\", $0)"
    let v67 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1 v66 
    let v68 : string = "fable_library_rust::String_::fromString($0)"
    let v69 : string = Fable.Core.RustInterop.emitRustExpr v67 v68 
    let _v65 = v69 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v70 : string = "format!(\"{:#?}\", $0)"
    let v71 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1 v70 
    let v72 : string = "fable_library_rust::String_::fromString($0)"
    let v73 : string = Fable.Core.RustInterop.emitRustExpr v71 v72 
    let _v65 = v73 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v74 : string = "format!(\"{:#?}\", $0)"
    let v75 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1 v74 
    let v76 : string = "fable_library_rust::String_::fromString($0)"
    let v77 : string = Fable.Core.RustInterop.emitRustExpr v75 v76 
    let _v65 = v77 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v78 : string = $"%A{v1}"
    let _v65 = v78 
    #endif
#if FABLE_COMPILER_PYTHON
    let v81 : string = $"%A{v1}"
    let _v65 = v81 
    #endif
#else
    let v84 : string = $"%A{v1}"
    let _v65 = v84 
    #endif
    let v87 : string = _v65 
    let v92 : string = $"{v87}"
    let v95 : unit = ()
    let v96 : (unit -> unit) = closure6(v3, v92)
    let v97 : unit = (fun () -> v96 (); v95) ()
    let v100 : string = " }"
    let v101 : string = $"{v100}"
    let v104 : unit = ()
    let v105 : (unit -> unit) = closure6(v3, v101)
    let v106 : unit = (fun () -> v105 (); v104) ()
    let v109 : string = v3.l0
    v109
and method64 (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 = method65(v8, v9)
    let v11 : int64 = v0.l0
    let v12 : string = "file_system.create_dir"
    let v13 : string = $"{v6} {v7} #{v11} %s{v12} / {v10}"
    method22(v13)
and closure38 (v0 : string, v1 : std_string_String) () : unit =
    let v2 : US0 = US0_4
    let v3 : bool = method10(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure0()
        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 = method11(v20, v21, v22, v23, v24, v25)
        let v39 : string = method42()
        let v40 : string = method64(v20, v21, v22, v23, v24, v25, v38, v39, v0, v1)
        method23(v40)
and method67 (v0 : string) : string =
    let v1 : string = method17()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure6(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "dir"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure6(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure6(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : string = $"{v0}"
    let v33 : unit = ()
    let v34 : (unit -> unit) = closure6(v2, v30)
    let v35 : unit = (fun () -> v34 (); v33) ()
    let v38 : string = " }"
    let v39 : string = $"{v38}"
    let v42 : unit = ()
    let v43 : (unit -> unit) = closure6(v2, v39)
    let v44 : unit = (fun () -> v43 (); v42) ()
    let v47 : string = v2.l0
    v47
and method66 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string) : string =
    let v9 : string = method67(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "file_system.create_dir"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method22(v12)
and closure39 (v0 : string) () : unit =
    let v1 : US0 = US0_0
    let v2 : bool = method10(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure0()
        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 = method11(v19, v20, v21, v22, v23, v24)
        let v38 : string = method39()
        let v39 : string = method66(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method23(v39)
and closure40 (v0 : string) () : unit =
    let v1 : bool = true
    method7(v1, v0)
and method68 (v0 : string) : (unit -> unit) =
    closure40(v0)
and method69 (v0 : string) : (unit -> unit) =
    closure40(v0)
and method71 (v0 : string, v1 : string) : string =
    let v2 : string = method17()
    let v3 : Mut3 = {l0 = v2} : Mut3
    let v4 : string = "{ "
    let v5 : string = $"{v4}"
    let v8 : unit = ()
    let v9 : (unit -> unit) = closure6(v3, v5)
    let v10 : unit = (fun () -> v9 (); v8) ()
    let v13 : string = "dir"
    let v14 : string = $"{v13}"
    let v17 : unit = ()
    let v18 : (unit -> unit) = closure6(v3, v14)
    let v19 : unit = (fun () -> v18 (); v17) ()
    let v22 : string = " = "
    let v23 : string = $"{v22}"
    let v26 : unit = ()
    let v27 : (unit -> unit) = closure6(v3, v23)
    let v28 : unit = (fun () -> v27 (); v26) ()
    let v31 : string = $"{v0}"
    let v34 : unit = ()
    let v35 : (unit -> unit) = closure6(v3, v31)
    let v36 : unit = (fun () -> v35 (); v34) ()
    let v39 : string = "; "
    let v40 : string = $"{v39}"
    let v43 : unit = ()
    let v44 : (unit -> unit) = closure6(v3, v40)
    let v45 : unit = (fun () -> v44 (); v43) ()
    let v48 : string = "result"
    let v49 : string = $"{v48}"
    let v52 : unit = ()
    let v53 : (unit -> unit) = closure6(v3, v49)
    let v54 : unit = (fun () -> v53 (); v52) ()
    let v57 : string = $"{v22}"
    let v60 : unit = ()
    let v61 : (unit -> unit) = closure6(v3, v57)
    let v62 : unit = (fun () -> v61 (); v60) ()
    let v65 : string = $"{v1}"
    let v68 : unit = ()
    let v69 : (unit -> unit) = closure6(v3, v65)
    let v70 : unit = (fun () -> v69 (); v68) ()
    let v73 : string = " }"
    let v74 : string = $"{v73}"
    let v77 : unit = ()
    let v78 : (unit -> unit) = closure6(v3, v74)
    let v79 : unit = (fun () -> v78 (); v77) ()
    let v82 : string = v3.l0
    v82
and method70 (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 = method71(v8, v9)
    let v11 : int64 = v0.l0
    let v12 : string = "file_system.create_dir"
    let v13 : string = $"{v6} {v7} #{v11} %s{v12} / {v10}"
    method22(v13)
and closure41 (v0 : string, v1 : string) () : unit =
    let v2 : US0 = US0_1
    let v3 : bool = method10(v2)
    if v3 then
        let v4 : unit = ()
        let v5 : (unit -> unit) = closure0()
        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 = method11(v20, v21, v22, v23, v24, v25)
        let v39 : string = method15()
        let v40 : string = method70(v20, v21, v22, v23, v24, v25, v38, v39, v0, v1)
        method23(v40)
and closure42 (v0 : string) () : unit =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v2 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v5 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v5 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v8 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v8 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v11 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v11 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : Async<int64> = null |> unbox<Async<int64>>
    let _v1 = v14 
    #endif
#else
    let v17 : int64 = 0L
    let v18 : Async<int64> = method6(v0, v17)
    let _v1 = v18 
    #endif
    let v19 : Async<int64> = _v1 
    let v24 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v25 : Async<unit> = null |> unbox<Async<unit>>
    let _v24 = v25 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v28 : Async<unit> = null |> unbox<Async<unit>>
    let _v24 = v28 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v31 : Async<unit> = null |> unbox<Async<unit>>
    let _v24 = v31 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v34 : Async<unit> = null |> unbox<Async<unit>>
    let _v24 = v34 
    #endif
#if FABLE_COMPILER_PYTHON
    let v37 : Async<unit> = null |> unbox<Async<unit>>
    let _v24 = v37 
    #endif
#else
    let v40 : (Async<int64> -> Async<unit>) = Async.Ignore
    let v41 : Async<unit> = v40 v19
    let _v24 = v41 
    #endif
    let v42 : Async<unit> = _v24 
    let v47 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    null |> unbox<unit>
    let _v47 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    null |> unbox<unit>
    let _v47 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    null |> unbox<unit>
    let _v47 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    null |> unbox<unit>
    let _v47 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    null |> unbox<unit>
    let _v47 = () 
    #endif
#else
    let v48 : (Async<unit> -> unit) = Async.RunSynchronously
    v48 v42
    let _v47 = () 
    #endif
    _v47 
    ()
and method72 (v0 : string) : (unit -> unit) =
    closure42(v0)
and method73 (v0 : string) : (unit -> unit) =
    closure42(v0)
and method61 (v0 : string) : System.IDisposable =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = method62(v0)
    let v3 : string = "std::fs::create_dir_all(&*$0)"
    let v4 : Result<unit, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2 v3 
    let v5 : (std_io_Error -> std_string_String) = method63()
    let v6 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v7 : string = "$0.map_err(|x| $1(x))"
    let v8 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v4, v5) v7 
    let _v6 = v8 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v9 : string = "$0.map_err(|x| $1(x))"
    let v10 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v4, v5) v9 
    let _v6 = v10 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v11 : string = "$0.map_err(|x| $1(x))"
    let v12 : Result<unit, std_string_String> = Fable.Core.RustInterop.emitRustExpr struct (v4, v5) v11 
    let _v6 = v12 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v13 : Result<unit, std_string_String> = match v4 with Ok x -> Ok x | Error x -> Error (v5 x)
    let _v6 = v13 
    #endif
#if FABLE_COMPILER_PYTHON
    let v14 : Result<unit, std_string_String> = match v4 with Ok x -> Ok x | Error x -> Error (v5 x)
    let _v6 = v14 
    #endif
#else
    let v15 : Result<unit, std_string_String> = match v4 with Ok x -> Ok x | Error x -> Error (v5 x)
    let _v6 = v15 
    #endif
    let v16 : Result<unit, std_string_String> = _v6 
    let v19 : (unit -> US12) = closure36()
    let v20 : (std_string_String -> US12) = closure37()
    let v21 : US12 = match v16 with Ok () -> v19 () | Error x -> v20 x
    match v21 with
    | US12_1(v64) -> (* Error *)
        let v65 : unit = ()
        let v66 : (unit -> unit) = closure38(v2, v64)
        let v67 : unit = (fun () -> v66 (); v65) ()
        ()
    | US12_0 -> (* Ok *)
        let v22 : unit = ()
        let v23 : (unit -> unit) = closure39(v2)
        let v24 : unit = (fun () -> v23 (); v22) ()
        ()
    let v107 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v108 : (unit -> unit) = method68(v2)
    let v109 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v108 "$0()" )
    let _v107 = v109 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v110 : (unit -> unit) = method68(v2)
    let v111 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v110 "$0()" )
    let _v107 = v111 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v112 : (unit -> unit) = method68(v2)
    let v113 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v112 "$0()" )
    let _v107 = v113 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v114 : (unit -> unit) = method69(v2)
    let v115 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v114 () }
    let _v107 = v115 
    #endif
#if FABLE_COMPILER_PYTHON
    let v116 : (unit -> unit) = method69(v2)
    let v117 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v116 () }
    let _v107 = v117 
    #endif
#else
    let v118 : (unit -> unit) = method69(v2)
    let v119 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v118 () }
    let _v107 = v119 
    #endif
    let v120 : System.IDisposable = _v107 
    let _v1 = v120 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v124 : System.IDisposable = null |> unbox<System.IDisposable>
    let _v1 = v124 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v127 : System.IDisposable = null |> unbox<System.IDisposable>
    let _v1 = v127 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v130 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v131 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v130 = v131 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v134 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v130 = v134 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v137 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v130 = v137 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v140 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v130 = v140 
    #endif
#if FABLE_COMPILER_PYTHON
    let v143 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v130 = v143 
    #endif
#else
    let v146 : (string -> System.IO.DirectoryInfo) = System.IO.Directory.CreateDirectory
    let v147 : System.IO.DirectoryInfo = v146 v0
    let _v130 = v147 
    #endif
    let v148 : System.IO.DirectoryInfo = _v130 
    let v153 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v154 : bool = null |> unbox<bool>
    let _v153 = v154 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v157 : bool = null |> unbox<bool>
    let _v153 = v157 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v160 : bool = null |> unbox<bool>
    let _v153 = v160 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v163 : bool = null |> unbox<bool>
    let _v153 = v163 
    #endif
#if FABLE_COMPILER_PYTHON
    let v166 : bool = null |> unbox<bool>
    let _v153 = v166 
    #endif
#else
    let v169 : bool = v148.Exists
    let _v153 = v169 
    #endif
    let v170 : bool = _v153 
    let v175 : bool = v170 = false
    if v175 then
        let v176 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v177 : System.DateTime = null |> unbox<System.DateTime>
        let _v176 = v177 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v180 : System.DateTime = null |> unbox<System.DateTime>
        let _v176 = v180 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v183 : System.DateTime = null |> unbox<System.DateTime>
        let _v176 = v183 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v186 : System.DateTime = null |> unbox<System.DateTime>
        let _v176 = v186 
        #endif
#if FABLE_COMPILER_PYTHON
        let v189 : System.DateTime = null |> unbox<System.DateTime>
        let _v176 = v189 
        #endif
#else
        let v192 : System.DateTime = v148.CreationTime
        let _v176 = v192 
        #endif
        let v193 : System.DateTime = _v176 
        let v198 : _ = {| Exists = v170; CreationTime = v193 |}
        let v199 : string = $"%A{v198}"
        let v202 : unit = ()
        let v203 : (unit -> unit) = closure41(v0, v199)
        let v204 : unit = (fun () -> v203 (); v202) ()
        ()
    let v244 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v245 : (unit -> unit) = method72(v0)
    let v246 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v245 "$0()" )
    let _v244 = v246 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v247 : (unit -> unit) = method72(v0)
    let v248 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v247 "$0()" )
    let _v244 = v248 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v249 : (unit -> unit) = method72(v0)
    let v250 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v249 "$0()" )
    let _v244 = v250 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v251 : (unit -> unit) = method73(v0)
    let v252 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v251 () }
    let _v244 = v252 
    #endif
#if FABLE_COMPILER_PYTHON
    let v253 : (unit -> unit) = method73(v0)
    let v254 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v253 () }
    let _v244 = v254 
    #endif
#else
    let v255 : (unit -> unit) = method73(v0)
    let v256 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v255 () }
    let _v244 = v256 
    #endif
    let v257 : System.IDisposable = _v244 
    let _v1 = v257 
    #endif
#if FABLE_COMPILER_PYTHON
    let v261 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v262 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v261 = v262 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v265 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v261 = v265 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v268 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v261 = v268 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v271 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v261 = v271 
    #endif
#if FABLE_COMPILER_PYTHON
    let v274 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v261 = v274 
    #endif
#else
    let v277 : (string -> System.IO.DirectoryInfo) = System.IO.Directory.CreateDirectory
    let v278 : System.IO.DirectoryInfo = v277 v0
    let _v261 = v278 
    #endif
    let v279 : System.IO.DirectoryInfo = _v261 
    let v284 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v285 : bool = null |> unbox<bool>
    let _v284 = v285 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v288 : bool = null |> unbox<bool>
    let _v284 = v288 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v291 : bool = null |> unbox<bool>
    let _v284 = v291 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v294 : bool = null |> unbox<bool>
    let _v284 = v294 
    #endif
#if FABLE_COMPILER_PYTHON
    let v297 : bool = null |> unbox<bool>
    let _v284 = v297 
    #endif
#else
    let v300 : bool = v279.Exists
    let _v284 = v300 
    #endif
    let v301 : bool = _v284 
    let v306 : bool = v301 = false
    if v306 then
        let v307 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v308 : System.DateTime = null |> unbox<System.DateTime>
        let _v307 = v308 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v311 : System.DateTime = null |> unbox<System.DateTime>
        let _v307 = v311 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v314 : System.DateTime = null |> unbox<System.DateTime>
        let _v307 = v314 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v317 : System.DateTime = null |> unbox<System.DateTime>
        let _v307 = v317 
        #endif
#if FABLE_COMPILER_PYTHON
        let v320 : System.DateTime = null |> unbox<System.DateTime>
        let _v307 = v320 
        #endif
#else
        let v323 : System.DateTime = v279.CreationTime
        let _v307 = v323 
        #endif
        let v324 : System.DateTime = _v307 
        let v329 : _ = {| Exists = v301; CreationTime = v324 |}
        let v330 : string = $"%A{v329}"
        let v333 : unit = ()
        let v334 : (unit -> unit) = closure41(v0, v330)
        let v335 : unit = (fun () -> v334 (); v333) ()
        ()
    let v375 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v376 : (unit -> unit) = method72(v0)
    let v377 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v376 "$0()" )
    let _v375 = v377 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v378 : (unit -> unit) = method72(v0)
    let v379 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v378 "$0()" )
    let _v375 = v379 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v380 : (unit -> unit) = method72(v0)
    let v381 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v380 "$0()" )
    let _v375 = v381 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v382 : (unit -> unit) = method73(v0)
    let v383 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v382 () }
    let _v375 = v383 
    #endif
#if FABLE_COMPILER_PYTHON
    let v384 : (unit -> unit) = method73(v0)
    let v385 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v384 () }
    let _v375 = v385 
    #endif
#else
    let v386 : (unit -> unit) = method73(v0)
    let v387 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v386 () }
    let _v375 = v387 
    #endif
    let v388 : System.IDisposable = _v375 
    let _v1 = v388 
    #endif
#else
    let v392 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v393 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v392 = v393 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v396 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v392 = v396 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v399 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v392 = v399 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v402 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v392 = v402 
    #endif
#if FABLE_COMPILER_PYTHON
    let v405 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v392 = v405 
    #endif
#else
    let v408 : (string -> System.IO.DirectoryInfo) = System.IO.Directory.CreateDirectory
    let v409 : System.IO.DirectoryInfo = v408 v0
    let _v392 = v409 
    #endif
    let v410 : System.IO.DirectoryInfo = _v392 
    let v415 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v416 : bool = null |> unbox<bool>
    let _v415 = v416 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v419 : bool = null |> unbox<bool>
    let _v415 = v419 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v422 : bool = null |> unbox<bool>
    let _v415 = v422 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v425 : bool = null |> unbox<bool>
    let _v415 = v425 
    #endif
#if FABLE_COMPILER_PYTHON
    let v428 : bool = null |> unbox<bool>
    let _v415 = v428 
    #endif
#else
    let v431 : bool = v410.Exists
    let _v415 = v431 
    #endif
    let v432 : bool = _v415 
    let v437 : bool = v432 = false
    if v437 then
        let v438 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v439 : System.DateTime = null |> unbox<System.DateTime>
        let _v438 = v439 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let v442 : System.DateTime = null |> unbox<System.DateTime>
        let _v438 = v442 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let v445 : System.DateTime = null |> unbox<System.DateTime>
        let _v438 = v445 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let v448 : System.DateTime = null |> unbox<System.DateTime>
        let _v438 = v448 
        #endif
#if FABLE_COMPILER_PYTHON
        let v451 : System.DateTime = null |> unbox<System.DateTime>
        let _v438 = v451 
        #endif
#else
        let v454 : System.DateTime = v410.CreationTime
        let _v438 = v454 
        #endif
        let v455 : System.DateTime = _v438 
        let v460 : _ = {| Exists = v432; CreationTime = v455 |}
        let v461 : string = $"%A{v460}"
        let v464 : unit = ()
        let v465 : (unit -> unit) = closure41(v0, v461)
        let v466 : unit = (fun () -> v465 (); v464) ()
        ()
    let v506 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v507 : (unit -> unit) = method72(v0)
    let v508 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v507 "$0()" )
    let _v506 = v508 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v509 : (unit -> unit) = method72(v0)
    let v510 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v509 "$0()" )
    let _v506 = v510 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v511 : (unit -> unit) = method72(v0)
    let v512 : System.IDisposable = new Disposable (fun () -> Fable.Core.RustInterop.emitRustExpr v511 "$0()" )
    let _v506 = v512 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v513 : (unit -> unit) = method73(v0)
    let v514 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v513 () }
    let _v506 = v514 
    #endif
#if FABLE_COMPILER_PYTHON
    let v515 : (unit -> unit) = method73(v0)
    let v516 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v515 () }
    let _v506 = v516 
    #endif
#else
    let v517 : (unit -> unit) = method73(v0)
    let v518 : System.IDisposable = { new System.IDisposable with member _.Dispose () = v517 () }
    let _v506 = v518 
    #endif
    let v519 : System.IDisposable = _v506 
    let _v1 = v519 
    #endif
    let v523 : System.IDisposable = _v1 
    v523
and closure34 () () : struct (string * System.IDisposable) =
    let v0 : string = method47()
    let v1 : System.IDisposable = method61(v0)
    struct (v0, v1)
and method74 (v0 : string) : System.Guid =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = v0.PadLeft (32, '0')
    let v16 : System.Guid = System.Guid $"{v2.[0..7]}-{v2.[8..11]}-{v2.[12..15]}-{v2.[16..19]}-{v2.[20..31]}"
    let _v1 = v16 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v19 : string = v0.PadLeft (32, '0')
    let v33 : System.Guid = System.Guid $"{v19.[0..7]}-{v19.[8..11]}-{v19.[12..15]}-{v19.[16..19]}-{v19.[20..31]}"
    let _v1 = v33 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v36 : System.Guid = null |> unbox<System.Guid>
    let _v1 = v36 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v39 : string = v0.PadLeft (32, '0')
    let v53 : System.Guid = System.Guid $"{v39.[0..7]}-{v39.[8..11]}-{v39.[12..15]}-{v39.[16..19]}-{v39.[20..31]}"
    let _v1 = v53 
    #endif
#if FABLE_COMPILER_PYTHON
    let v56 : string = v0.PadLeft (32, '0')
    let v70 : System.Guid = System.Guid $"{v56.[0..7]}-{v56.[8..11]}-{v56.[12..15]}-{v56.[16..19]}-{v56.[20..31]}"
    let _v1 = v70 
    #endif
#else
    let v73 : string = v0.PadLeft (32, '0')
    let v87 : System.Guid = System.Guid $"{v73.[0..7]}-{v73.[8..11]}-{v73.[12..15]}-{v73.[16..19]}-{v73.[20..31]}"
    let _v1 = v87 
    #endif
    let v90 : System.Guid = _v1 
    v90
and closure43 () (v0 : string) : struct (string * System.IDisposable) =
    let v1 : System.Guid = method74(v0)
    let v2 : string = method53(v1)
    let v3 : System.IDisposable = method61(v2)
    struct (v2, v3)
and closure44 () () : string =
    let v0 : string = __SOURCE_DIRECTORY__
    v0
and method77 (v0 : std_io_Error) : string =
    let v1 : string = method17()
    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) = closure6(v2, v30)
    let v35 : unit = (fun () -> v34 (); v33) ()
    let v38 : string = v2.l0
    v38
and closure46 () (v0 : std_io_Error) : string =
    method77(v0)
and method76 () : (std_io_Error -> string) =
    closure46()
and closure47 () (v0 : std_path_PathBuf) : US13 =
    US13_0(v0)
and closure48 () (v0 : string) : US13 =
    US13_1(v0)
and method79 (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 method78 (v0 : string) : string option =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v2 : string = method79(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 closure49 () (v0 : std_path_PathBuf) : US14 =
    US14_0(v0)
and method80 () : (std_path_PathBuf -> US14) =
    closure49()
and method82 (v0 : string) : string =
    v0
and method81 (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 = method82(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 method75 (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 = method9(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) = method76()
                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 -> US13) = closure47()
                let v24 : (string -> US13) = closure48()
                let v25 : US13 = match v20 with Ok x -> v23 x | Error x -> v24 x
                match v25 with
                | US13_1(v40) -> (* Error *)
                    let v41 : string = method19(v0)
                    let v42 : string option = method78(v0)
                    let v43 : (string -> US1) = method4()
                    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) = method76()
                            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 : US13 = match v78 with Ok x -> v23 x | Error x -> v24 x
                            let v2744 : Result<std_path_PathBuf, std_io_Error> =
                                match v81 with
                                | US13_1(v96) -> (* Error *)
                                    let v97 : string = method19(v60)
                                    let v98 : string option = method78(v60)
                                    let v99 : (string -> US1) = method4()
                                    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) = method76()
                                            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 : US13 = match v133 with Ok x -> v23 x | Error x -> v24 x
                                            let v2539 : Result<std_path_PathBuf, std_io_Error> =
                                                match v136 with
                                                | US13_1(v151) -> (* Error *)
                                                    let v152 : string = method19(v116)
                                                    let v153 : string option = method78(v116)
                                                    let v154 : (string -> US1) = method4()
                                                    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) = method76()
                                                            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 : US13 = match v188 with Ok x -> v23 x | Error x -> v24 x
                                                            let v2334 : Result<std_path_PathBuf, std_io_Error> =
                                                                match v191 with
                                                                | US13_1(v206) -> (* Error *)
                                                                    let v207 : string = method19(v171)
                                                                    let v208 : string option = method78(v171)
                                                                    let v209 : (string -> US1) = method4()
                                                                    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) = method76()
                                                                            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 : US13 = match v243 with Ok x -> v23 x | Error x -> v24 x
                                                                            let v2129 : Result<std_path_PathBuf, std_io_Error> =
                                                                                match v246 with
                                                                                | US13_1(v261) -> (* Error *)
                                                                                    let v262 : string = method19(v226)
                                                                                    let v263 : string option = method78(v226)
                                                                                    let v264 : (string -> US1) = method4()
                                                                                    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) = method76()
                                                                                            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 : US13 = match v298 with Ok x -> v23 x | Error x -> v24 x
                                                                                            let v1924 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                match v301 with
                                                                                                | US13_1(v316) -> (* Error *)
                                                                                                    let v317 : string = method19(v281)
                                                                                                    let v318 : string option = method78(v281)
                                                                                                    let v319 : (string -> US1) = method4()
                                                                                                    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) = method76()
                                                                                                            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 : US13 = match v353 with Ok x -> v23 x | Error x -> v24 x
                                                                                                            let v1719 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                match v356 with
                                                                                                                | US13_1(v371) -> (* Error *)
                                                                                                                    let v372 : string = method19(v336)
                                                                                                                    let v373 : string option = method78(v336)
                                                                                                                    let v374 : (string -> US1) = method4()
                                                                                                                    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) = method76()
                                                                                                                            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 : US13 = match v408 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                            let v1514 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                match v411 with
                                                                                                                                | US13_1(v426) -> (* Error *)
                                                                                                                                    let v427 : string = method19(v391)
                                                                                                                                    let v428 : string option = method78(v391)
                                                                                                                                    let v429 : (string -> US1) = method4()
                                                                                                                                    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) = method76()
                                                                                                                                            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 : US13 = match v463 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                            let v1309 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                match v466 with
                                                                                                                                                | US13_1(v481) -> (* Error *)
                                                                                                                                                    let v482 : string = method19(v446)
                                                                                                                                                    let v483 : string option = method78(v446)
                                                                                                                                                    let v484 : (string -> US1) = method4()
                                                                                                                                                    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) = method76()
                                                                                                                                                            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 : US13 = match v518 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                            let v1104 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                match v521 with
                                                                                                                                                                | US13_1(v536) -> (* Error *)
                                                                                                                                                                    let v537 : string = method19(v501)
                                                                                                                                                                    let v538 : string option = method78(v501)
                                                                                                                                                                    let v539 : (string -> US1) = method4()
                                                                                                                                                                    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) = method76()
                                                                                                                                                                            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 : US13 = match v573 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                                            let v899 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                match v576 with
                                                                                                                                                                                | US13_1(v591) -> (* Error *)
                                                                                                                                                                                    let v592 : string = method19(v556)
                                                                                                                                                                                    let v593 : string option = method78(v556)
                                                                                                                                                                                    let v594 : (string -> US1) = method4()
                                                                                                                                                                                    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) = method76()
                                                                                                                                                                                            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 : US13 = match v628 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                                                            let v694 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                match v631 with
                                                                                                                                                                                                | US13_1(v646) -> (* Error *)
                                                                                                                                                                                                    let v647 : string = method19(v611)
                                                                                                                                                                                                    let v648 : string option = method78(v611)
                                                                                                                                                                                                    let v649 : (string -> US1) = method4()
                                                                                                                                                                                                    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
                                                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                                                            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 : US13 = match v706 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                                                            match v709 with
                                                                                                                                                                                            | US13_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
                                                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                                            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 : US13 = match v911 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                                            match v914 with
                                                                                                                                                                            | US13_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
                                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                            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 : US13 = match v1116 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                                            match v1119 with
                                                                                                                                                            | US13_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
                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                | US13_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) = method76()
                                                                                                                                            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 : US13 = match v1321 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                                            match v1324 with
                                                                                                                                            | US13_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
                                                                                                                                            | US13_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 = method56(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
                                                                                                                                | US13_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) = method76()
                                                                                                                            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 : US13 = match v1526 with Ok x -> v23 x | Error x -> v24 x
                                                                                                                            match v1529 with
                                                                                                                            | US13_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
                                                                                                                            | US13_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 = method56(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
                                                                                                                | US13_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) = method76()
                                                                                                            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 : US13 = match v1731 with Ok x -> v23 x | Error x -> v24 x
                                                                                                            match v1734 with
                                                                                                            | US13_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
                                                                                                            | US13_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 = method56(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
                                                                                                | US13_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) = method76()
                                                                                            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 : US13 = match v1936 with Ok x -> v23 x | Error x -> v24 x
                                                                                            match v1939 with
                                                                                            | US13_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
                                                                                            | US13_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 = method56(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
                                                                                | US13_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) = method76()
                                                                            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 : US13 = match v2141 with Ok x -> v23 x | Error x -> v24 x
                                                                            match v2144 with
                                                                            | US13_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
                                                                            | US13_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 = method56(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
                                                                | US13_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) = method76()
                                                            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 : US13 = match v2346 with Ok x -> v23 x | Error x -> v24 x
                                                            match v2349 with
                                                            | US13_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
                                                            | US13_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 = method56(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
                                                | US13_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) = method76()
                                            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 : US13 = match v2551 with Ok x -> v23 x | Error x -> v24 x
                                            match v2554 with
                                            | US13_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
                                            | US13_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 = method56(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
                                | US13_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) = method76()
                            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 : US13 = match v2756 with Ok x -> v23 x | Error x -> v24 x
                            match v2759 with
                            | US13_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
                            | US13_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 = method56(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
                | US13_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 = method9(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) = method76()
                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 -> US13) = closure47()
                let v2971 : (string -> US13) = closure48()
                let v2972 : US13 = match v2967 with Ok x -> v2970 x | Error x -> v2971 x
                match v2972 with
                | US13_1(v2987) -> (* Error *)
                    let v2988 : string = method19(v0)
                    let v2989 : string option = method78(v0)
                    let v2990 : (string -> US1) = method4()
                    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) = method76()
                            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 : US13 = match v3025 with Ok x -> v2970 x | Error x -> v2971 x
                            let v5691 : Result<std_path_PathBuf, std_io_Error> =
                                match v3028 with
                                | US13_1(v3043) -> (* Error *)
                                    let v3044 : string = method19(v3007)
                                    let v3045 : string option = method78(v3007)
                                    let v3046 : (string -> US1) = method4()
                                    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) = method76()
                                            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 : US13 = match v3080 with Ok x -> v2970 x | Error x -> v2971 x
                                            let v5486 : Result<std_path_PathBuf, std_io_Error> =
                                                match v3083 with
                                                | US13_1(v3098) -> (* Error *)
                                                    let v3099 : string = method19(v3063)
                                                    let v3100 : string option = method78(v3063)
                                                    let v3101 : (string -> US1) = method4()
                                                    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) = method76()
                                                            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 : US13 = match v3135 with Ok x -> v2970 x | Error x -> v2971 x
                                                            let v5281 : Result<std_path_PathBuf, std_io_Error> =
                                                                match v3138 with
                                                                | US13_1(v3153) -> (* Error *)
                                                                    let v3154 : string = method19(v3118)
                                                                    let v3155 : string option = method78(v3118)
                                                                    let v3156 : (string -> US1) = method4()
                                                                    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) = method76()
                                                                            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 : US13 = match v3190 with Ok x -> v2970 x | Error x -> v2971 x
                                                                            let v5076 : Result<std_path_PathBuf, std_io_Error> =
                                                                                match v3193 with
                                                                                | US13_1(v3208) -> (* Error *)
                                                                                    let v3209 : string = method19(v3173)
                                                                                    let v3210 : string option = method78(v3173)
                                                                                    let v3211 : (string -> US1) = method4()
                                                                                    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) = method76()
                                                                                            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 : US13 = match v3245 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                            let v4871 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                match v3248 with
                                                                                                | US13_1(v3263) -> (* Error *)
                                                                                                    let v3264 : string = method19(v3228)
                                                                                                    let v3265 : string option = method78(v3228)
                                                                                                    let v3266 : (string -> US1) = method4()
                                                                                                    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) = method76()
                                                                                                            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 : US13 = match v3300 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                            let v4666 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                match v3303 with
                                                                                                                | US13_1(v3318) -> (* Error *)
                                                                                                                    let v3319 : string = method19(v3283)
                                                                                                                    let v3320 : string option = method78(v3283)
                                                                                                                    let v3321 : (string -> US1) = method4()
                                                                                                                    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) = method76()
                                                                                                                            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 : US13 = match v3355 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                            let v4461 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                match v3358 with
                                                                                                                                | US13_1(v3373) -> (* Error *)
                                                                                                                                    let v3374 : string = method19(v3338)
                                                                                                                                    let v3375 : string option = method78(v3338)
                                                                                                                                    let v3376 : (string -> US1) = method4()
                                                                                                                                    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) = method76()
                                                                                                                                            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 : US13 = match v3410 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                            let v4256 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                match v3413 with
                                                                                                                                                | US13_1(v3428) -> (* Error *)
                                                                                                                                                    let v3429 : string = method19(v3393)
                                                                                                                                                    let v3430 : string option = method78(v3393)
                                                                                                                                                    let v3431 : (string -> US1) = method4()
                                                                                                                                                    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) = method76()
                                                                                                                                                            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 : US13 = match v3465 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                            let v4051 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                match v3468 with
                                                                                                                                                                | US13_1(v3483) -> (* Error *)
                                                                                                                                                                    let v3484 : string = method19(v3448)
                                                                                                                                                                    let v3485 : string option = method78(v3448)
                                                                                                                                                                    let v3486 : (string -> US1) = method4()
                                                                                                                                                                    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) = method76()
                                                                                                                                                                            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 : US13 = match v3520 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                                            let v3846 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                match v3523 with
                                                                                                                                                                                | US13_1(v3538) -> (* Error *)
                                                                                                                                                                                    let v3539 : string = method19(v3503)
                                                                                                                                                                                    let v3540 : string option = method78(v3503)
                                                                                                                                                                                    let v3541 : (string -> US1) = method4()
                                                                                                                                                                                    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) = method76()
                                                                                                                                                                                            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 : US13 = match v3575 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                                                            let v3641 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                match v3578 with
                                                                                                                                                                                                | US13_1(v3593) -> (* Error *)
                                                                                                                                                                                                    let v3594 : string = method19(v3558)
                                                                                                                                                                                                    let v3595 : string option = method78(v3558)
                                                                                                                                                                                                    let v3596 : (string -> US1) = method4()
                                                                                                                                                                                                    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
                                                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                                                            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 : US13 = match v3653 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                                                            match v3656 with
                                                                                                                                                                                            | US13_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
                                                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                                            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 : US13 = match v3858 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                                            match v3861 with
                                                                                                                                                                            | US13_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
                                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                            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 : US13 = match v4063 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                                            match v4066 with
                                                                                                                                                            | US13_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
                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                | US13_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) = method76()
                                                                                                                                            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 : US13 = match v4268 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                                            match v4271 with
                                                                                                                                            | US13_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
                                                                                                                                            | US13_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 = method56(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
                                                                                                                                | US13_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) = method76()
                                                                                                                            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 : US13 = match v4473 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                                            match v4476 with
                                                                                                                            | US13_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
                                                                                                                            | US13_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 = method56(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
                                                                                                                | US13_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) = method76()
                                                                                                            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 : US13 = match v4678 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                                            match v4681 with
                                                                                                            | US13_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
                                                                                                            | US13_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 = method56(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
                                                                                                | US13_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) = method76()
                                                                                            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 : US13 = match v4883 with Ok x -> v2970 x | Error x -> v2971 x
                                                                                            match v4886 with
                                                                                            | US13_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
                                                                                            | US13_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 = method56(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
                                                                                | US13_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) = method76()
                                                                            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 : US13 = match v5088 with Ok x -> v2970 x | Error x -> v2971 x
                                                                            match v5091 with
                                                                            | US13_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
                                                                            | US13_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 = method56(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
                                                                | US13_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) = method76()
                                                            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 : US13 = match v5293 with Ok x -> v2970 x | Error x -> v2971 x
                                                            match v5296 with
                                                            | US13_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
                                                            | US13_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 = method56(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
                                                | US13_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) = method76()
                                            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 : US13 = match v5498 with Ok x -> v2970 x | Error x -> v2971 x
                                            match v5501 with
                                            | US13_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
                                            | US13_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 = method56(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
                                | US13_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) = method76()
                            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 : US13 = match v5703 with Ok x -> v2970 x | Error x -> v2971 x
                            match v5706 with
                            | US13_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
                            | US13_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 = method56(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
                | US13_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 = method9(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) = method76()
                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 -> US13) = closure47()
                let v5918 : (string -> US13) = closure48()
                let v5919 : US13 = match v5914 with Ok x -> v5917 x | Error x -> v5918 x
                match v5919 with
                | US13_1(v5934) -> (* Error *)
                    let v5935 : string = method19(v0)
                    let v5936 : string option = method78(v0)
                    let v5937 : (string -> US1) = method4()
                    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) = method76()
                            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 : US13 = match v5972 with Ok x -> v5917 x | Error x -> v5918 x
                            let v8638 : Result<std_path_PathBuf, std_io_Error> =
                                match v5975 with
                                | US13_1(v5990) -> (* Error *)
                                    let v5991 : string = method19(v5954)
                                    let v5992 : string option = method78(v5954)
                                    let v5993 : (string -> US1) = method4()
                                    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) = method76()
                                            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 : US13 = match v6027 with Ok x -> v5917 x | Error x -> v5918 x
                                            let v8433 : Result<std_path_PathBuf, std_io_Error> =
                                                match v6030 with
                                                | US13_1(v6045) -> (* Error *)
                                                    let v6046 : string = method19(v6010)
                                                    let v6047 : string option = method78(v6010)
                                                    let v6048 : (string -> US1) = method4()
                                                    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) = method76()
                                                            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 : US13 = match v6082 with Ok x -> v5917 x | Error x -> v5918 x
                                                            let v8228 : Result<std_path_PathBuf, std_io_Error> =
                                                                match v6085 with
                                                                | US13_1(v6100) -> (* Error *)
                                                                    let v6101 : string = method19(v6065)
                                                                    let v6102 : string option = method78(v6065)
                                                                    let v6103 : (string -> US1) = method4()
                                                                    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) = method76()
                                                                            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 : US13 = match v6137 with Ok x -> v5917 x | Error x -> v5918 x
                                                                            let v8023 : Result<std_path_PathBuf, std_io_Error> =
                                                                                match v6140 with
                                                                                | US13_1(v6155) -> (* Error *)
                                                                                    let v6156 : string = method19(v6120)
                                                                                    let v6157 : string option = method78(v6120)
                                                                                    let v6158 : (string -> US1) = method4()
                                                                                    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) = method76()
                                                                                            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 : US13 = match v6192 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                            let v7818 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                match v6195 with
                                                                                                | US13_1(v6210) -> (* Error *)
                                                                                                    let v6211 : string = method19(v6175)
                                                                                                    let v6212 : string option = method78(v6175)
                                                                                                    let v6213 : (string -> US1) = method4()
                                                                                                    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) = method76()
                                                                                                            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 : US13 = match v6247 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                            let v7613 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                match v6250 with
                                                                                                                | US13_1(v6265) -> (* Error *)
                                                                                                                    let v6266 : string = method19(v6230)
                                                                                                                    let v6267 : string option = method78(v6230)
                                                                                                                    let v6268 : (string -> US1) = method4()
                                                                                                                    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) = method76()
                                                                                                                            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 : US13 = match v6302 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                            let v7408 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                match v6305 with
                                                                                                                                | US13_1(v6320) -> (* Error *)
                                                                                                                                    let v6321 : string = method19(v6285)
                                                                                                                                    let v6322 : string option = method78(v6285)
                                                                                                                                    let v6323 : (string -> US1) = method4()
                                                                                                                                    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) = method76()
                                                                                                                                            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 : US13 = match v6357 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                            let v7203 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                match v6360 with
                                                                                                                                                | US13_1(v6375) -> (* Error *)
                                                                                                                                                    let v6376 : string = method19(v6340)
                                                                                                                                                    let v6377 : string option = method78(v6340)
                                                                                                                                                    let v6378 : (string -> US1) = method4()
                                                                                                                                                    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) = method76()
                                                                                                                                                            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 : US13 = match v6412 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                            let v6998 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                match v6415 with
                                                                                                                                                                | US13_1(v6430) -> (* Error *)
                                                                                                                                                                    let v6431 : string = method19(v6395)
                                                                                                                                                                    let v6432 : string option = method78(v6395)
                                                                                                                                                                    let v6433 : (string -> US1) = method4()
                                                                                                                                                                    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) = method76()
                                                                                                                                                                            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 : US13 = match v6467 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                                            let v6793 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                match v6470 with
                                                                                                                                                                                | US13_1(v6485) -> (* Error *)
                                                                                                                                                                                    let v6486 : string = method19(v6450)
                                                                                                                                                                                    let v6487 : string option = method78(v6450)
                                                                                                                                                                                    let v6488 : (string -> US1) = method4()
                                                                                                                                                                                    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) = method76()
                                                                                                                                                                                            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 : US13 = match v6522 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                                                            let v6588 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                match v6525 with
                                                                                                                                                                                                | US13_1(v6540) -> (* Error *)
                                                                                                                                                                                                    let v6541 : string = method19(v6505)
                                                                                                                                                                                                    let v6542 : string option = method78(v6505)
                                                                                                                                                                                                    let v6543 : (string -> US1) = method4()
                                                                                                                                                                                                    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
                                                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                                                            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 : US13 = match v6600 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                                                            match v6603 with
                                                                                                                                                                                            | US13_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
                                                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                                            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 : US13 = match v6805 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                                            match v6808 with
                                                                                                                                                                            | US13_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
                                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                                | US13_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) = method76()
                                                                                                                                                            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 : US13 = match v7010 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                                            match v7013 with
                                                                                                                                                            | US13_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
                                                                                                                                                            | US13_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 = method56(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
                                                                                                                                                | US13_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) = method76()
                                                                                                                                            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 : US13 = match v7215 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                                            match v7218 with
                                                                                                                                            | US13_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
                                                                                                                                            | US13_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 = method56(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
                                                                                                                                | US13_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) = method76()
                                                                                                                            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 : US13 = match v7420 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                                            match v7423 with
                                                                                                                            | US13_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
                                                                                                                            | US13_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 = method56(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
                                                                                                                | US13_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) = method76()
                                                                                                            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 : US13 = match v7625 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                                            match v7628 with
                                                                                                            | US13_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
                                                                                                            | US13_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 = method56(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
                                                                                                | US13_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) = method76()
                                                                                            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 : US13 = match v7830 with Ok x -> v5917 x | Error x -> v5918 x
                                                                                            match v7833 with
                                                                                            | US13_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
                                                                                            | US13_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 = method56(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
                                                                                | US13_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) = method76()
                                                                            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 : US13 = match v8035 with Ok x -> v5917 x | Error x -> v5918 x
                                                                            match v8038 with
                                                                            | US13_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
                                                                            | US13_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 = method56(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
                                                                | US13_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) = method76()
                                                            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 : US13 = match v8240 with Ok x -> v5917 x | Error x -> v5918 x
                                                            match v8243 with
                                                            | US13_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
                                                            | US13_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 = method56(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
                                                | US13_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) = method76()
                                            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 : US13 = match v8445 with Ok x -> v5917 x | Error x -> v5918 x
                                            match v8448 with
                                            | US13_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
                                            | US13_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 = method56(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
                                | US13_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) = method76()
                            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 : US13 = match v8650 with Ok x -> v5917 x | Error x -> v5918 x
                            match v8653 with
                            | US13_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
                            | US13_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 = method56(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
                | US13_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 = method19(v0)
                let v8993 : string option = method78(v0)
                let v8994 : (string -> US1) = method4()
                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 = method19(v9011)
                                let v9160 : string option = method78(v9011)
                                let v9161 : (string -> US1) = method4()
                                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 = method19(v9178)
                                                let v9326 : string option = method78(v9178)
                                                let v9327 : (string -> US1) = method4()
                                                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 = method19(v9344)
                                                                let v9492 : string option = method78(v9344)
                                                                let v9493 : (string -> US1) = method4()
                                                                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 = method19(v9510)
                                                                                let v9658 : string option = method78(v9510)
                                                                                let v9659 : (string -> US1) = method4()
                                                                                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 = method19(v9676)
                                                                                                let v9824 : string option = method78(v9676)
                                                                                                let v9825 : (string -> US1) = method4()
                                                                                                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 = method19(v9842)
                                                                                                                let v9990 : string option = method78(v9842)
                                                                                                                let v9991 : (string -> US1) = method4()
                                                                                                                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 = method19(v10008)
                                                                                                                                let v10156 : string option = method78(v10008)
                                                                                                                                let v10157 : (string -> US1) = method4()
                                                                                                                                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 = method19(v10174)
                                                                                                                                                let v10322 : string option = method78(v10174)
                                                                                                                                                let v10323 : (string -> US1) = method4()
                                                                                                                                                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 = method19(v10340)
                                                                                                                                                                let v10488 : string option = method78(v10340)
                                                                                                                                                                let v10489 : (string -> US1) = method4()
                                                                                                                                                                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 = method19(v10506)
                                                                                                                                                                                let v10654 : string option = method78(v10506)
                                                                                                                                                                                let v10655 : (string -> US1) = method4()
                                                                                                                                                                                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 = method19(v10672)
                                                                                                                                                                                                let v10820 : string option = method78(v10672)
                                                                                                                                                                                                let v10821 : (string -> US1) = method4()
                                                                                                                                                                                                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) = method76()
                                                                                                                                                                                        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 -> US13) = closure47()
                                                                                                                                                                                        let v10881 : (string -> US13) = closure48()
                                                                                                                                                                                        let v10882 : US13 = match v10877 with Ok x -> v10880 x | Error x -> v10881 x
                                                                                                                                                                                        match v10882 with
                                                                                                                                                                                        | US13_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
                                                                                                                                                                                        | US13_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 = method56(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) = method76()
                                                                                                                                                                        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 -> US13) = closure47()
                                                                                                                                                                        let v11087 : (string -> US13) = closure48()
                                                                                                                                                                        let v11088 : US13 = match v11083 with Ok x -> v11086 x | Error x -> v11087 x
                                                                                                                                                                        match v11088 with
                                                                                                                                                                        | US13_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
                                                                                                                                                                        | US13_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 = method56(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) = method76()
                                                                                                                                                        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 -> US13) = closure47()
                                                                                                                                                        let v11293 : (string -> US13) = closure48()
                                                                                                                                                        let v11294 : US13 = match v11289 with Ok x -> v11292 x | Error x -> v11293 x
                                                                                                                                                        match v11294 with
                                                                                                                                                        | US13_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
                                                                                                                                                        | US13_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 = method56(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) = method76()
                                                                                                                                        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 -> US13) = closure47()
                                                                                                                                        let v11499 : (string -> US13) = closure48()
                                                                                                                                        let v11500 : US13 = match v11495 with Ok x -> v11498 x | Error x -> v11499 x
                                                                                                                                        match v11500 with
                                                                                                                                        | US13_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
                                                                                                                                        | US13_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 = method56(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) = method76()
                                                                                                                        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 -> US13) = closure47()
                                                                                                                        let v11705 : (string -> US13) = closure48()
                                                                                                                        let v11706 : US13 = match v11701 with Ok x -> v11704 x | Error x -> v11705 x
                                                                                                                        match v11706 with
                                                                                                                        | US13_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
                                                                                                                        | US13_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 = method56(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) = method76()
                                                                                                        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 -> US13) = closure47()
                                                                                                        let v11911 : (string -> US13) = closure48()
                                                                                                        let v11912 : US13 = match v11907 with Ok x -> v11910 x | Error x -> v11911 x
                                                                                                        match v11912 with
                                                                                                        | US13_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
                                                                                                        | US13_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 = method56(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) = method76()
                                                                                        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 -> US13) = closure47()
                                                                                        let v12117 : (string -> US13) = closure48()
                                                                                        let v12118 : US13 = match v12113 with Ok x -> v12116 x | Error x -> v12117 x
                                                                                        match v12118 with
                                                                                        | US13_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
                                                                                        | US13_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 = method56(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) = method76()
                                                                        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 -> US13) = closure47()
                                                                        let v12323 : (string -> US13) = closure48()
                                                                        let v12324 : US13 = match v12319 with Ok x -> v12322 x | Error x -> v12323 x
                                                                        match v12324 with
                                                                        | US13_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
                                                                        | US13_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 = method56(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) = method76()
                                                        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 -> US13) = closure47()
                                                        let v12529 : (string -> US13) = closure48()
                                                        let v12530 : US13 = match v12525 with Ok x -> v12528 x | Error x -> v12529 x
                                                        match v12530 with
                                                        | US13_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
                                                        | US13_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 = method56(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) = method76()
                                        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 -> US13) = closure47()
                                        let v12735 : (string -> US13) = closure48()
                                        let v12736 : US13 = match v12731 with Ok x -> v12734 x | Error x -> v12735 x
                                        match v12736 with
                                        | US13_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
                                        | US13_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 = method56(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) = method76()
                        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 -> US13) = closure47()
                        let v12941 : (string -> US13) = closure48()
                        let v12942 : US13 = match v12937 with Ok x -> v12940 x | Error x -> v12941 x
                        match v12942 with
                        | US13_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
                        | US13_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 = method56(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 -> US14) = method80()
        let v13149 : US14 option = v13145 |> Option.map v13148 
        let v13160 : US14 = US14_1
        let v13161 : US14 = v13149 |> Option.defaultValue v13160 
        let v13193 : string =
            match v13161 with
            | US14_1 -> (* None *)
                v0
            | US14_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 = method81(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 closure45 () (v0 : string) : string =
    method75(v0)
and closure50 () (v0 : string) : string =
    let v1 : char list = []
    let v2 : char list = '/' :: v1 
    let v5 : (char list -> (char [])) = List.toArray
    let v6 : (char []) = v5 v2
    let v9 : string = v0.TrimStart v6 
    let v27 : string = $"file:///{v9}"
    v27
and closure52 () (v0 : string) : string option =
    method78(v0)
and method84 () : (string -> string option) =
    closure52()
and method85 (v0 : string, v1 : string, v2 : string) : US15 =
    let v3 : string = method56(v2, v0)
    let v4 : bool = method9(v3)
    if v4 then
        US15_0(v2)
    else
        let v6 : (string -> string option) = method84()
        let v7 : string option = v6 v2
        let v8 : (string -> US1) = method4()
        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}')"""
            US15_1(v27)
        | US1_0(v25) -> (* Some *)
            method85(v0, v1, v25)
and method83 (v0 : string, v1 : string) : US15 =
    let v2 : string = method56(v1, v0)
    let v3 : bool = method9(v2)
    if v3 then
        US15_0(v1)
    else
        let v5 : (string -> string option) = method84()
        let v6 : string option = v5 v1
        let v7 : (string -> US1) = method4()
        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}')"""
            US15_1(v26)
        | US1_0(v24) -> (* Some *)
            method85(v0, v1, v24)
and method87 (v0 : string) : string =
    let v1 : string = method17()
    let v2 : Mut3 = {l0 = v1} : Mut3
    let v3 : string = "{ "
    let v4 : string = $"{v3}"
    let v7 : unit = ()
    let v8 : (unit -> unit) = closure6(v2, v4)
    let v9 : unit = (fun () -> v8 (); v7) ()
    let v12 : string = "error"
    let v13 : string = $"{v12}"
    let v16 : unit = ()
    let v17 : (unit -> unit) = closure6(v2, v13)
    let v18 : unit = (fun () -> v17 (); v16) ()
    let v21 : string = " = "
    let v22 : string = $"{v21}"
    let v25 : unit = ()
    let v26 : (unit -> unit) = closure6(v2, v22)
    let v27 : unit = (fun () -> v26 (); v25) ()
    let v30 : string = $"{v0}"
    let v33 : unit = ()
    let v34 : (unit -> unit) = closure6(v2, v30)
    let v35 : unit = (fun () -> v34 (); v33) ()
    let v38 : string = " }"
    let v39 : string = $"{v38}"
    let v42 : unit = ()
    let v43 : (unit -> unit) = closure6(v2, v39)
    let v44 : unit = (fun () -> v43 (); v42) ()
    let v47 : string = v2.l0
    v47
and method86 (v0 : Mut0, v1 : Mut1, v2 : Mut2, v3 : Mut3, v4 : Mut4, v5 : int64 option, v6 : string, v7 : string, v8 : string) : string =
    let v9 : string = method87(v8)
    let v10 : int64 = v0.l0
    let v11 : string = "file_system.get_workspace_root"
    let v12 : string = $"{v6} {v7} #{v10} %s{v11} / {v9}"
    method22(v12)
and closure53 (v0 : string) () : unit =
    let v1 : US0 = US0_3
    let v2 : bool = method10(v1)
    if v2 then
        let v3 : unit = ()
        let v4 : (unit -> unit) = closure0()
        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 = method11(v19, v20, v21, v22, v23, v24)
        let v38 : string = method32()
        let v39 : string = method86(v19, v20, v21, v22, v23, v24, v37, v38, v0)
        method23(v39)
and method88 () : 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 closure51 () () : string =
    let v0 : string = __SOURCE_DIRECTORY__
    let v1 : string = "polyglot"
    let v2 : string = ".devcontainer"
    let v3 : string = method56(v1, v2)
    let v4 : US15 = method83(v3, v0)
    let v52 : US1 =
        match v4 with
        | US15_1(v7) -> (* Error *)
            let v8 : unit = ()
            let v9 : (unit -> unit) = closure53(v7)
            let v10 : unit = (fun () -> v9 (); v8) ()
            US1_1
        | US15_0(v5) -> (* Ok *)
            US1_0(v5)
    let v107 : US1 =
        match v52 with
        | US1_1 -> (* None *)
            let v55 : string = method88()
            let v56 : string = method56(v1, v2)
            let v57 : US15 = method83(v56, v55)
            match v57 with
            | US15_1(v60) -> (* Error *)
                let v61 : unit = ()
                let v62 : (unit -> unit) = closure53(v60)
                let v63 : unit = (fun () -> v62 (); v61) ()
                US1_1
            | US15_0(v58) -> (* Ok *)
                US1_0(v58)
        | US1_0(v53) -> (* Some *)
            US1_0(v53)
    let v111 : string =
        match v107 with
        | US1_1 -> (* None *)
            failwith<string> "Option does not have a value."
        | US1_0(v108) -> (* Some *)
            v108
    method56(v111, v1)
and method89 (v0 : string) : unit =
    let v1 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let _v1 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let _v1 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let _v1 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let _v1 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    let _v1 = () 
    #endif
#else
    try
    let v2 : string = method59()
    let v3 : System.DateTime = System.DateTime.Now
    let v6 : (unit -> System.Guid) = System.Guid.NewGuid
    let v7 : System.Guid = v6 ()
    let v10 : System.Guid = method48(v7, v3)
    let v11 : string = $"{v2}_{v10}.txt"
    let v12 : string = __SOURCE_DIRECTORY__
    let v13 : string = "polyglot"
    let v14 : string = ".devcontainer"
    let v15 : string = method56(v13, v14)
    let v16 : US15 = method83(v15, v12)
    let v64 : US1 =
        match v16 with
        | US15_1(v19) -> (* Error *)
            let v20 : unit = ()
            let v21 : (unit -> unit) = closure53(v19)
            let v22 : unit = (fun () -> v21 (); v20) ()
            US1_1
        | US15_0(v17) -> (* Ok *)
            US1_0(v17)
    let v119 : US1 =
        match v64 with
        | US1_1 -> (* None *)
            let v67 : string = method88()
            let v68 : string = method56(v13, v14)
            let v69 : US15 = method83(v68, v67)
            match v69 with
            | US15_1(v72) -> (* Error *)
                let v73 : unit = ()
                let v74 : (unit -> unit) = closure53(v72)
                let v75 : unit = (fun () -> v74 (); v73) ()
                US1_1
            | US15_0(v70) -> (* Ok *)
                US1_0(v70)
        | US1_0(v65) -> (* Some *)
            US1_0(v65)
    let v123 : string =
        match v119 with
        | US1_1 -> (* None *)
            failwith<string> "Option does not have a value."
        | US1_0(v120) -> (* Some *)
            v120
    let v124 : string = method56(v123, v13)
    let v125 : string = "target/trace"
    let v126 : string = method56(v124, v125)
    let v127 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v128 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v127 = v128 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v131 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v127 = v131 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v134 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v127 = v134 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v137 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v127 = v137 
    #endif
#if FABLE_COMPILER_PYTHON
    let v140 : System.IO.DirectoryInfo = null |> unbox<System.IO.DirectoryInfo>
    let _v127 = v140 
    #endif
#else
    let v143 : (string -> System.IO.DirectoryInfo) = System.IO.Directory.CreateDirectory
    let v144 : System.IO.DirectoryInfo = v143 v126
    let _v127 = v144 
    #endif
    let v145 : System.IO.DirectoryInfo = _v127 
    let v150 : string = method56(v126, v11)
    let v151 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v152 : Async<unit> = null |> unbox<Async<unit>>
    let _v151 = v152 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v155 : Async<unit> = null |> unbox<Async<unit>>
    let _v151 = v155 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v158 : Async<unit> = null |> unbox<Async<unit>>
    let _v151 = v158 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v161 : Async<unit> = null |> unbox<Async<unit>>
    let _v151 = v161 
    #endif
#if FABLE_COMPILER_PYTHON
    let v164 : Async<unit> = null |> unbox<Async<unit>>
    let _v151 = v164 
    #endif
#else
    let v167 : System.Threading.Tasks.Task = System.IO.File.WriteAllTextAsync (v150, v0)
    let v168 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    let v169 : Async<unit> = null |> unbox<Async<unit>>
    let _v168 = v169 
    #endif
#if FABLE_COMPILER_RUST && WASM
    let v172 : Async<unit> = null |> unbox<Async<unit>>
    let _v168 = v172 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    let v175 : Async<unit> = null |> unbox<Async<unit>>
    let _v168 = v175 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    let v178 : Async<unit> = null |> unbox<Async<unit>>
    let _v168 = v178 
    #endif
#if FABLE_COMPILER_PYTHON
    let v181 : Async<unit> = null |> unbox<Async<unit>>
    let _v168 = v181 
    #endif
#else
    let v184 : (System.Threading.Tasks.Task -> Async<unit>) = Async.AwaitTask
    let v185 : Async<unit> = v184 v167
    let _v168 = v185 
    #endif
    let v186 : Async<unit> = _v168 
    let _v151 = v186 
    #endif
    let v191 : Async<unit> = _v151 
    let v196 : unit = ()
    
#if FABLE_COMPILER || WASM || CONTRACT
    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
    null |> unbox<unit>
    let _v196 = () 
    #endif
#if FABLE_COMPILER_RUST && WASM
    null |> unbox<unit>
    let _v196 = () 
    #endif
#if FABLE_COMPILER_RUST && CONTRACT
    null |> unbox<unit>
    let _v196 = () 
    #endif
#if FABLE_COMPILER_TYPESCRIPT
    null |> unbox<unit>
    let _v196 = () 
    #endif
#if FABLE_COMPILER_PYTHON
    null |> unbox<unit>
    let _v196 = () 
    #endif
#else
    let v197 : (Async<unit> -> unit) = Async.RunSynchronously
    v197 v191
    let _v196 = () 
    #endif
    _v196 
    with ex ->
    let v198 : exn = ex
    let v199 : string = $"file_system.trace_file / ex: %A{v198}"
    method89(v199)
    (*
    *)
    let _v1 = () 
    #endif
    _v1 
    ()
and closure55 () (v0 : string) : unit =
    method89(v0)
and closure54 () (v0 : bool) : unit =
    let v1 : unit = ()
    let v2 : (unit -> unit) = closure0()
    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 v37 : (string -> unit) =
        if v0 then
            closure55()
        else
            closure2()
    v18.l0 <- v37
    ()
and method90 (v0 : string, v1 : string) : unit =
    let v2 : bool = method9(v0)
    let v3 : bool = v2 = false
    if v3 then
        let v4 : System.IDisposable = method61(v0)
        ()
    let v5 : string = method79(v1)
    let v6 : bool = method9(v5)
    let v7 : bool = v6 = false
    if v7 then
        let v8 : System.IDisposable = method61(v5)
        ()
    let v9 : bool = method9(v1)
    let v13151 : bool =
        if v9 then
            let v10 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v11 : bool = method9(v1)
            let v2957 : Result<std_path_PathBuf, std_io_Error> =
                if v11 then
                    let v12 : string = "std::fs::read_link(&*$0)"
                    let v13 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1 v12 
                    v13
                else
                    let v14 : string = "std::fs::read_link(&*$0)"
                    let v15 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1 v14 
                    let v16 : (std_io_Error -> string) = method76()
                    let v17 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v18 : string = "$0.map_err(|x| $1(x))"
                    let v19 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v15, v16) v18 
                    let _v17 = v19 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v20 : string = "$0.map_err(|x| $1(x))"
                    let v21 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v15, v16) v20 
                    let _v17 = v21 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v22 : string = "$0.map_err(|x| $1(x))"
                    let v23 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v15, v16) v22 
                    let _v17 = v23 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v24 : Result<std_path_PathBuf, string> = match v15 with Ok x -> Ok x | Error x -> Error (v16 x)
                    let _v17 = v24 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v25 : Result<std_path_PathBuf, string> = match v15 with Ok x -> Ok x | Error x -> Error (v16 x)
                    let _v17 = v25 
                    #endif
#else
                    let v26 : Result<std_path_PathBuf, string> = match v15 with Ok x -> Ok x | Error x -> Error (v16 x)
                    let _v17 = v26 
                    #endif
                    let v27 : Result<std_path_PathBuf, string> = _v17 
                    let v30 : (std_path_PathBuf -> US13) = closure47()
                    let v31 : (string -> US13) = closure48()
                    let v32 : US13 = match v27 with Ok x -> v30 x | Error x -> v31 x
                    match v32 with
                    | US13_1(v47) -> (* Error *)
                        let v48 : string = method19(v1)
                        let v49 : string option = method78(v1)
                        let v50 : (string -> US1) = method4()
                        let v51 : US1 option = v49 |> Option.map v50 
                        let v62 : US1 = US1_1
                        let v63 : US1 = v51 |> Option.defaultValue v62 
                        match v63 with
                        | US1_0(v67) -> (* Some *)
                            let v68 : string = ""
                            let v69 : bool = v1 <> v68 
                            if v69 then
                                let v72 : string = "std::fs::read_link(&*$0)"
                                let v73 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v67 v72 
                                let v74 : (std_io_Error -> string) = method76()
                                let v75 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v76 : string = "$0.map_err(|x| $1(x))"
                                let v77 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v73, v74) v76 
                                let _v75 = v77 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v78 : string = "$0.map_err(|x| $1(x))"
                                let v79 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v73, v74) v78 
                                let _v75 = v79 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v80 : string = "$0.map_err(|x| $1(x))"
                                let v81 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v73, v74) v80 
                                let _v75 = v81 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v82 : Result<std_path_PathBuf, string> = match v73 with Ok x -> Ok x | Error x -> Error (v74 x)
                                let _v75 = v82 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v83 : Result<std_path_PathBuf, string> = match v73 with Ok x -> Ok x | Error x -> Error (v74 x)
                                let _v75 = v83 
                                #endif
#else
                                let v84 : Result<std_path_PathBuf, string> = match v73 with Ok x -> Ok x | Error x -> Error (v74 x)
                                let _v75 = v84 
                                #endif
                                let v85 : Result<std_path_PathBuf, string> = _v75 
                                let v88 : US13 = match v85 with Ok x -> v30 x | Error x -> v31 x
                                let v2751 : Result<std_path_PathBuf, std_io_Error> =
                                    match v88 with
                                    | US13_1(v103) -> (* Error *)
                                        let v104 : string = method19(v67)
                                        let v105 : string option = method78(v67)
                                        let v106 : (string -> US1) = method4()
                                        let v107 : US1 option = v105 |> Option.map v106 
                                        let v118 : US1 = US1_1
                                        let v119 : US1 = v107 |> Option.defaultValue v118 
                                        match v119 with
                                        | US1_0(v123) -> (* Some *)
                                            let v124 : bool = v67 <> v68 
                                            if v124 then
                                                let v127 : string = "std::fs::read_link(&*$0)"
                                                let v128 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v123 v127 
                                                let v129 : (std_io_Error -> string) = method76()
                                                let v130 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v131 : string = "$0.map_err(|x| $1(x))"
                                                let v132 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v128, v129) v131 
                                                let _v130 = v132 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v133 : string = "$0.map_err(|x| $1(x))"
                                                let v134 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v128, v129) v133 
                                                let _v130 = v134 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v135 : string = "$0.map_err(|x| $1(x))"
                                                let v136 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v128, v129) v135 
                                                let _v130 = v136 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v137 : Result<std_path_PathBuf, string> = match v128 with Ok x -> Ok x | Error x -> Error (v129 x)
                                                let _v130 = v137 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v138 : Result<std_path_PathBuf, string> = match v128 with Ok x -> Ok x | Error x -> Error (v129 x)
                                                let _v130 = v138 
                                                #endif
#else
                                                let v139 : Result<std_path_PathBuf, string> = match v128 with Ok x -> Ok x | Error x -> Error (v129 x)
                                                let _v130 = v139 
                                                #endif
                                                let v140 : Result<std_path_PathBuf, string> = _v130 
                                                let v143 : US13 = match v140 with Ok x -> v30 x | Error x -> v31 x
                                                let v2546 : Result<std_path_PathBuf, std_io_Error> =
                                                    match v143 with
                                                    | US13_1(v158) -> (* Error *)
                                                        let v159 : string = method19(v123)
                                                        let v160 : string option = method78(v123)
                                                        let v161 : (string -> US1) = method4()
                                                        let v162 : US1 option = v160 |> Option.map v161 
                                                        let v173 : US1 = US1_1
                                                        let v174 : US1 = v162 |> Option.defaultValue v173 
                                                        match v174 with
                                                        | US1_0(v178) -> (* Some *)
                                                            let v179 : bool = v123 <> v68 
                                                            if v179 then
                                                                let v182 : string = "std::fs::read_link(&*$0)"
                                                                let v183 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v178 v182 
                                                                let v184 : (std_io_Error -> string) = method76()
                                                                let v185 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v186 : string = "$0.map_err(|x| $1(x))"
                                                                let v187 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v183, v184) v186 
                                                                let _v185 = v187 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v188 : string = "$0.map_err(|x| $1(x))"
                                                                let v189 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v183, v184) v188 
                                                                let _v185 = v189 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v190 : string = "$0.map_err(|x| $1(x))"
                                                                let v191 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v183, v184) v190 
                                                                let _v185 = v191 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v192 : Result<std_path_PathBuf, string> = match v183 with Ok x -> Ok x | Error x -> Error (v184 x)
                                                                let _v185 = v192 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v193 : Result<std_path_PathBuf, string> = match v183 with Ok x -> Ok x | Error x -> Error (v184 x)
                                                                let _v185 = v193 
                                                                #endif
#else
                                                                let v194 : Result<std_path_PathBuf, string> = match v183 with Ok x -> Ok x | Error x -> Error (v184 x)
                                                                let _v185 = v194 
                                                                #endif
                                                                let v195 : Result<std_path_PathBuf, string> = _v185 
                                                                let v198 : US13 = match v195 with Ok x -> v30 x | Error x -> v31 x
                                                                let v2341 : Result<std_path_PathBuf, std_io_Error> =
                                                                    match v198 with
                                                                    | US13_1(v213) -> (* Error *)
                                                                        let v214 : string = method19(v178)
                                                                        let v215 : string option = method78(v178)
                                                                        let v216 : (string -> US1) = method4()
                                                                        let v217 : US1 option = v215 |> Option.map v216 
                                                                        let v228 : US1 = US1_1
                                                                        let v229 : US1 = v217 |> Option.defaultValue v228 
                                                                        match v229 with
                                                                        | US1_0(v233) -> (* Some *)
                                                                            let v234 : bool = v178 <> v68 
                                                                            if v234 then
                                                                                let v237 : string = "std::fs::read_link(&*$0)"
                                                                                let v238 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v233 v237 
                                                                                let v239 : (std_io_Error -> string) = method76()
                                                                                let v240 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v241 : string = "$0.map_err(|x| $1(x))"
                                                                                let v242 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v238, v239) v241 
                                                                                let _v240 = v242 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v243 : string = "$0.map_err(|x| $1(x))"
                                                                                let v244 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v238, v239) v243 
                                                                                let _v240 = v244 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v245 : string = "$0.map_err(|x| $1(x))"
                                                                                let v246 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v238, v239) v245 
                                                                                let _v240 = v246 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v247 : Result<std_path_PathBuf, string> = match v238 with Ok x -> Ok x | Error x -> Error (v239 x)
                                                                                let _v240 = v247 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v248 : Result<std_path_PathBuf, string> = match v238 with Ok x -> Ok x | Error x -> Error (v239 x)
                                                                                let _v240 = v248 
                                                                                #endif
#else
                                                                                let v249 : Result<std_path_PathBuf, string> = match v238 with Ok x -> Ok x | Error x -> Error (v239 x)
                                                                                let _v240 = v249 
                                                                                #endif
                                                                                let v250 : Result<std_path_PathBuf, string> = _v240 
                                                                                let v253 : US13 = match v250 with Ok x -> v30 x | Error x -> v31 x
                                                                                let v2136 : Result<std_path_PathBuf, std_io_Error> =
                                                                                    match v253 with
                                                                                    | US13_1(v268) -> (* Error *)
                                                                                        let v269 : string = method19(v233)
                                                                                        let v270 : string option = method78(v233)
                                                                                        let v271 : (string -> US1) = method4()
                                                                                        let v272 : US1 option = v270 |> Option.map v271 
                                                                                        let v283 : US1 = US1_1
                                                                                        let v284 : US1 = v272 |> Option.defaultValue v283 
                                                                                        match v284 with
                                                                                        | US1_0(v288) -> (* Some *)
                                                                                            let v289 : bool = v233 <> v68 
                                                                                            if v289 then
                                                                                                let v292 : string = "std::fs::read_link(&*$0)"
                                                                                                let v293 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v288 v292 
                                                                                                let v294 : (std_io_Error -> string) = method76()
                                                                                                let v295 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v296 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v297 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v293, v294) v296 
                                                                                                let _v295 = v297 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v298 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v299 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v293, v294) v298 
                                                                                                let _v295 = v299 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v300 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v301 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v293, v294) v300 
                                                                                                let _v295 = v301 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v302 : Result<std_path_PathBuf, string> = match v293 with Ok x -> Ok x | Error x -> Error (v294 x)
                                                                                                let _v295 = v302 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v303 : Result<std_path_PathBuf, string> = match v293 with Ok x -> Ok x | Error x -> Error (v294 x)
                                                                                                let _v295 = v303 
                                                                                                #endif
#else
                                                                                                let v304 : Result<std_path_PathBuf, string> = match v293 with Ok x -> Ok x | Error x -> Error (v294 x)
                                                                                                let _v295 = v304 
                                                                                                #endif
                                                                                                let v305 : Result<std_path_PathBuf, string> = _v295 
                                                                                                let v308 : US13 = match v305 with Ok x -> v30 x | Error x -> v31 x
                                                                                                let v1931 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                    match v308 with
                                                                                                    | US13_1(v323) -> (* Error *)
                                                                                                        let v324 : string = method19(v288)
                                                                                                        let v325 : string option = method78(v288)
                                                                                                        let v326 : (string -> US1) = method4()
                                                                                                        let v327 : US1 option = v325 |> Option.map v326 
                                                                                                        let v338 : US1 = US1_1
                                                                                                        let v339 : US1 = v327 |> Option.defaultValue v338 
                                                                                                        match v339 with
                                                                                                        | US1_0(v343) -> (* Some *)
                                                                                                            let v344 : bool = v288 <> v68 
                                                                                                            if v344 then
                                                                                                                let v347 : string = "std::fs::read_link(&*$0)"
                                                                                                                let v348 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v343 v347 
                                                                                                                let v349 : (std_io_Error -> string) = method76()
                                                                                                                let v350 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v351 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v352 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v348, v349) v351 
                                                                                                                let _v350 = v352 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v353 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v354 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v348, v349) v353 
                                                                                                                let _v350 = v354 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v355 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v356 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v348, v349) v355 
                                                                                                                let _v350 = v356 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v357 : Result<std_path_PathBuf, string> = match v348 with Ok x -> Ok x | Error x -> Error (v349 x)
                                                                                                                let _v350 = v357 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v358 : Result<std_path_PathBuf, string> = match v348 with Ok x -> Ok x | Error x -> Error (v349 x)
                                                                                                                let _v350 = v358 
                                                                                                                #endif
#else
                                                                                                                let v359 : Result<std_path_PathBuf, string> = match v348 with Ok x -> Ok x | Error x -> Error (v349 x)
                                                                                                                let _v350 = v359 
                                                                                                                #endif
                                                                                                                let v360 : Result<std_path_PathBuf, string> = _v350 
                                                                                                                let v363 : US13 = match v360 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                let v1726 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                    match v363 with
                                                                                                                    | US13_1(v378) -> (* Error *)
                                                                                                                        let v379 : string = method19(v343)
                                                                                                                        let v380 : string option = method78(v343)
                                                                                                                        let v381 : (string -> US1) = method4()
                                                                                                                        let v382 : US1 option = v380 |> Option.map v381 
                                                                                                                        let v393 : US1 = US1_1
                                                                                                                        let v394 : US1 = v382 |> Option.defaultValue v393 
                                                                                                                        match v394 with
                                                                                                                        | US1_0(v398) -> (* Some *)
                                                                                                                            let v399 : bool = v343 <> v68 
                                                                                                                            if v399 then
                                                                                                                                let v402 : string = "std::fs::read_link(&*$0)"
                                                                                                                                let v403 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v398 v402 
                                                                                                                                let v404 : (std_io_Error -> string) = method76()
                                                                                                                                let v405 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v406 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v407 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v403, v404) v406 
                                                                                                                                let _v405 = v407 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v408 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v409 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v403, v404) v408 
                                                                                                                                let _v405 = v409 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v410 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v411 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v403, v404) v410 
                                                                                                                                let _v405 = v411 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v412 : Result<std_path_PathBuf, string> = match v403 with Ok x -> Ok x | Error x -> Error (v404 x)
                                                                                                                                let _v405 = v412 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v413 : Result<std_path_PathBuf, string> = match v403 with Ok x -> Ok x | Error x -> Error (v404 x)
                                                                                                                                let _v405 = v413 
                                                                                                                                #endif
#else
                                                                                                                                let v414 : Result<std_path_PathBuf, string> = match v403 with Ok x -> Ok x | Error x -> Error (v404 x)
                                                                                                                                let _v405 = v414 
                                                                                                                                #endif
                                                                                                                                let v415 : Result<std_path_PathBuf, string> = _v405 
                                                                                                                                let v418 : US13 = match v415 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                let v1521 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                    match v418 with
                                                                                                                                    | US13_1(v433) -> (* Error *)
                                                                                                                                        let v434 : string = method19(v398)
                                                                                                                                        let v435 : string option = method78(v398)
                                                                                                                                        let v436 : (string -> US1) = method4()
                                                                                                                                        let v437 : US1 option = v435 |> Option.map v436 
                                                                                                                                        let v448 : US1 = US1_1
                                                                                                                                        let v449 : US1 = v437 |> Option.defaultValue v448 
                                                                                                                                        match v449 with
                                                                                                                                        | US1_0(v453) -> (* Some *)
                                                                                                                                            let v454 : bool = v398 <> v68 
                                                                                                                                            if v454 then
                                                                                                                                                let v457 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                let v458 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v453 v457 
                                                                                                                                                let v459 : (std_io_Error -> string) = method76()
                                                                                                                                                let v460 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v461 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v462 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v458, v459) v461 
                                                                                                                                                let _v460 = v462 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v463 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v464 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v458, v459) v463 
                                                                                                                                                let _v460 = v464 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v465 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v466 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v458, v459) v465 
                                                                                                                                                let _v460 = v466 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v467 : Result<std_path_PathBuf, string> = match v458 with Ok x -> Ok x | Error x -> Error (v459 x)
                                                                                                                                                let _v460 = v467 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v468 : Result<std_path_PathBuf, string> = match v458 with Ok x -> Ok x | Error x -> Error (v459 x)
                                                                                                                                                let _v460 = v468 
                                                                                                                                                #endif
#else
                                                                                                                                                let v469 : Result<std_path_PathBuf, string> = match v458 with Ok x -> Ok x | Error x -> Error (v459 x)
                                                                                                                                                let _v460 = v469 
                                                                                                                                                #endif
                                                                                                                                                let v470 : Result<std_path_PathBuf, string> = _v460 
                                                                                                                                                let v473 : US13 = match v470 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                                let v1316 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                    match v473 with
                                                                                                                                                    | US13_1(v488) -> (* Error *)
                                                                                                                                                        let v489 : string = method19(v453)
                                                                                                                                                        let v490 : string option = method78(v453)
                                                                                                                                                        let v491 : (string -> US1) = method4()
                                                                                                                                                        let v492 : US1 option = v490 |> Option.map v491 
                                                                                                                                                        let v503 : US1 = US1_1
                                                                                                                                                        let v504 : US1 = v492 |> Option.defaultValue v503 
                                                                                                                                                        match v504 with
                                                                                                                                                        | US1_0(v508) -> (* Some *)
                                                                                                                                                            let v509 : bool = v453 <> v68 
                                                                                                                                                            if v509 then
                                                                                                                                                                let v512 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                let v513 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v508 v512 
                                                                                                                                                                let v514 : (std_io_Error -> string) = method76()
                                                                                                                                                                let v515 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v516 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v517 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v513, v514) v516 
                                                                                                                                                                let _v515 = v517 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v518 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v519 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v513, v514) v518 
                                                                                                                                                                let _v515 = v519 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v520 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v521 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v513, v514) v520 
                                                                                                                                                                let _v515 = v521 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v522 : Result<std_path_PathBuf, string> = match v513 with Ok x -> Ok x | Error x -> Error (v514 x)
                                                                                                                                                                let _v515 = v522 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v523 : Result<std_path_PathBuf, string> = match v513 with Ok x -> Ok x | Error x -> Error (v514 x)
                                                                                                                                                                let _v515 = v523 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v524 : Result<std_path_PathBuf, string> = match v513 with Ok x -> Ok x | Error x -> Error (v514 x)
                                                                                                                                                                let _v515 = v524 
                                                                                                                                                                #endif
                                                                                                                                                                let v525 : Result<std_path_PathBuf, string> = _v515 
                                                                                                                                                                let v528 : US13 = match v525 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                                                let v1111 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                    match v528 with
                                                                                                                                                                    | US13_1(v543) -> (* Error *)
                                                                                                                                                                        let v544 : string = method19(v508)
                                                                                                                                                                        let v545 : string option = method78(v508)
                                                                                                                                                                        let v546 : (string -> US1) = method4()
                                                                                                                                                                        let v547 : US1 option = v545 |> Option.map v546 
                                                                                                                                                                        let v558 : US1 = US1_1
                                                                                                                                                                        let v559 : US1 = v547 |> Option.defaultValue v558 
                                                                                                                                                                        match v559 with
                                                                                                                                                                        | US1_0(v563) -> (* Some *)
                                                                                                                                                                            let v564 : bool = v508 <> v68 
                                                                                                                                                                            if v564 then
                                                                                                                                                                                let v567 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                let v568 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v563 v567 
                                                                                                                                                                                let v569 : (std_io_Error -> string) = method76()
                                                                                                                                                                                let v570 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v571 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v572 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v568, v569) v571 
                                                                                                                                                                                let _v570 = v572 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v573 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v574 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v568, v569) v573 
                                                                                                                                                                                let _v570 = v574 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v575 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v576 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v568, v569) v575 
                                                                                                                                                                                let _v570 = v576 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v577 : Result<std_path_PathBuf, string> = match v568 with Ok x -> Ok x | Error x -> Error (v569 x)
                                                                                                                                                                                let _v570 = v577 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v578 : Result<std_path_PathBuf, string> = match v568 with Ok x -> Ok x | Error x -> Error (v569 x)
                                                                                                                                                                                let _v570 = v578 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v579 : Result<std_path_PathBuf, string> = match v568 with Ok x -> Ok x | Error x -> Error (v569 x)
                                                                                                                                                                                let _v570 = v579 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v580 : Result<std_path_PathBuf, string> = _v570 
                                                                                                                                                                                let v583 : US13 = match v580 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                                                                let v906 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                    match v583 with
                                                                                                                                                                                    | US13_1(v598) -> (* Error *)
                                                                                                                                                                                        let v599 : string = method19(v563)
                                                                                                                                                                                        let v600 : string option = method78(v563)
                                                                                                                                                                                        let v601 : (string -> US1) = method4()
                                                                                                                                                                                        let v602 : US1 option = v600 |> Option.map v601 
                                                                                                                                                                                        let v613 : US1 = US1_1
                                                                                                                                                                                        let v614 : US1 = v602 |> Option.defaultValue v613 
                                                                                                                                                                                        match v614 with
                                                                                                                                                                                        | US1_0(v618) -> (* Some *)
                                                                                                                                                                                            let v619 : bool = v563 <> v68 
                                                                                                                                                                                            if v619 then
                                                                                                                                                                                                let v622 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                                let v623 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v618 v622 
                                                                                                                                                                                                let v624 : (std_io_Error -> string) = method76()
                                                                                                                                                                                                let v625 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v626 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v627 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v623, v624) v626 
                                                                                                                                                                                                let _v625 = v627 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v628 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v629 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v623, v624) v628 
                                                                                                                                                                                                let _v625 = v629 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v630 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v631 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v623, v624) v630 
                                                                                                                                                                                                let _v625 = v631 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v632 : Result<std_path_PathBuf, string> = match v623 with Ok x -> Ok x | Error x -> Error (v624 x)
                                                                                                                                                                                                let _v625 = v632 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v633 : Result<std_path_PathBuf, string> = match v623 with Ok x -> Ok x | Error x -> Error (v624 x)
                                                                                                                                                                                                let _v625 = v633 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v634 : Result<std_path_PathBuf, string> = match v623 with Ok x -> Ok x | Error x -> Error (v624 x)
                                                                                                                                                                                                let _v625 = v634 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v635 : Result<std_path_PathBuf, string> = _v625 
                                                                                                                                                                                                let v638 : US13 = match v635 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                                                                                let v701 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                    match v638 with
                                                                                                                                                                                                    | US13_1(v653) -> (* Error *)
                                                                                                                                                                                                        let v654 : string = method19(v618)
                                                                                                                                                                                                        let v655 : string option = method78(v618)
                                                                                                                                                                                                        let v656 : (string -> US1) = method4()
                                                                                                                                                                                                        let v657 : US1 option = v655 |> Option.map v656 
                                                                                                                                                                                                        let v668 : US1 = US1_1
                                                                                                                                                                                                        let v669 : US1 = v657 |> Option.defaultValue v668 
                                                                                                                                                                                                        let v673 : string = $"file_system.read_link / path: {v1} / n: {11uy} / path': {v618} / name: {v654}"
                                                                                                                                                                                                        let v674 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v675 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v676 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v673 v675 
                                                                                                                                                                                                        let _v674 = v676 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v677 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v678 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v673 v677 
                                                                                                                                                                                                        let _v674 = v678 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v679 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v680 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v673 v679 
                                                                                                                                                                                                        let _v674 = v680 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v681 : std_io_Error = v673 
                                                                                                                                                                                                        let _v674 = v681 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v682 : std_io_Error = v673 
                                                                                                                                                                                                        let _v674 = v682 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v683 : std_io_Error = v673 
                                                                                                                                                                                                        let _v674 = v683 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v684 : std_io_Error = _v674 
                                                                                                                                                                                                        let v687 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v688 : string = "Err($0)"
                                                                                                                                                                                                        let v689 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v684 v688 
                                                                                                                                                                                                        let _v687 = v689 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v690 : string = "Err($0)"
                                                                                                                                                                                                        let v691 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v684 v690 
                                                                                                                                                                                                        let _v687 = v691 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v692 : string = "Err($0)"
                                                                                                                                                                                                        let v693 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v684 v692 
                                                                                                                                                                                                        let _v687 = v693 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v694 : Result<std_path_PathBuf, std_io_Error> = v684 |> Error
                                                                                                                                                                                                        let _v687 = v694 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v695 : Result<std_path_PathBuf, std_io_Error> = v684 |> Error
                                                                                                                                                                                                        let _v687 = v695 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v696 : Result<std_path_PathBuf, std_io_Error> = v684 |> Error
                                                                                                                                                                                                        let _v687 = v696 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v697 : Result<std_path_PathBuf, std_io_Error> = _v687 
                                                                                                                                                                                                        v697
                                                                                                                                                                                                    | US13_0(v639) -> (* Ok *)
                                                                                                                                                                                                        let v640 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v641 : string = "Ok($0)"
                                                                                                                                                                                                        let v642 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v639 v641 
                                                                                                                                                                                                        let _v640 = v642 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v643 : string = "Ok($0)"
                                                                                                                                                                                                        let v644 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v639 v643 
                                                                                                                                                                                                        let _v640 = v644 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v645 : string = "Ok($0)"
                                                                                                                                                                                                        let v646 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v639 v645 
                                                                                                                                                                                                        let _v640 = v646 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v647 : Result<std_path_PathBuf, std_io_Error> = v639 |> Ok
                                                                                                                                                                                                        let _v640 = v647 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v648 : Result<std_path_PathBuf, std_io_Error> = v639 |> Ok
                                                                                                                                                                                                        let _v640 = v648 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v649 : Result<std_path_PathBuf, std_io_Error> = v639 |> Ok
                                                                                                                                                                                                        let _v640 = v649 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v650 : Result<std_path_PathBuf, std_io_Error> = _v640 
                                                                                                                                                                                                        v650
                                                                                                                                                                                                let v702 : (std_io_Error -> string) = method76()
                                                                                                                                                                                                let v703 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v704 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v705 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v701, v702) v704 
                                                                                                                                                                                                let _v703 = v705 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v706 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v707 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v701, v702) v706 
                                                                                                                                                                                                let _v703 = v707 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v708 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v709 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v701, v702) v708 
                                                                                                                                                                                                let _v703 = v709 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v710 : Result<std_path_PathBuf, string> = match v701 with Ok x -> Ok x | Error x -> Error (v702 x)
                                                                                                                                                                                                let _v703 = v710 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v711 : Result<std_path_PathBuf, string> = match v701 with Ok x -> Ok x | Error x -> Error (v702 x)
                                                                                                                                                                                                let _v703 = v711 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v712 : Result<std_path_PathBuf, string> = match v701 with Ok x -> Ok x | Error x -> Error (v702 x)
                                                                                                                                                                                                let _v703 = v712 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v713 : Result<std_path_PathBuf, string> = _v703 
                                                                                                                                                                                                let v716 : US13 = match v713 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                                                                                match v716 with
                                                                                                                                                                                                | US13_1(v819) -> (* Error *)
                                                                                                                                                                                                    let v820 : string = $"file_system.read_link / error': {v819} / error: {v598} / name: {v599}"
                                                                                                                                                                                                    let v821 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v822 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v823 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v820 v822 
                                                                                                                                                                                                    let _v821 = v823 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v824 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v825 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v820 v824 
                                                                                                                                                                                                    let _v821 = v825 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v826 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v827 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v820 v826 
                                                                                                                                                                                                    let _v821 = v827 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v828 : std_io_Error = v820 
                                                                                                                                                                                                    let _v821 = v828 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v829 : std_io_Error = v820 
                                                                                                                                                                                                    let _v821 = v829 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v830 : std_io_Error = v820 
                                                                                                                                                                                                    let _v821 = v830 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v831 : std_io_Error = _v821 
                                                                                                                                                                                                    let v834 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v835 : string = "Err($0)"
                                                                                                                                                                                                    let v836 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v831 v835 
                                                                                                                                                                                                    let _v834 = v836 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v837 : string = "Err($0)"
                                                                                                                                                                                                    let v838 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v831 v837 
                                                                                                                                                                                                    let _v834 = v838 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v839 : string = "Err($0)"
                                                                                                                                                                                                    let v840 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v831 v839 
                                                                                                                                                                                                    let _v834 = v840 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v841 : Result<std_path_PathBuf, std_io_Error> = v831 |> Error
                                                                                                                                                                                                    let _v834 = v841 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v842 : Result<std_path_PathBuf, std_io_Error> = v831 |> Error
                                                                                                                                                                                                    let _v834 = v842 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v843 : Result<std_path_PathBuf, std_io_Error> = v831 |> Error
                                                                                                                                                                                                    let _v834 = v843 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v844 : Result<std_path_PathBuf, std_io_Error> = _v834 
                                                                                                                                                                                                    v844
                                                                                                                                                                                                | US13_0(v717) -> (* Ok *)
                                                                                                                                                                                                    let v718 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v719 : string = "$0.display()"
                                                                                                                                                                                                    let v720 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v717 v719 
                                                                                                                                                                                                    let _v718 = v720 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v721 : string = "$0.display()"
                                                                                                                                                                                                    let v722 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v717 v721 
                                                                                                                                                                                                    let _v718 = v722 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v723 : string = "$0.display()"
                                                                                                                                                                                                    let v724 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v717 v723 
                                                                                                                                                                                                    let _v718 = v724 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v725 : std_path_Display = v717 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v718 = v725 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v728 : std_path_Display = v717 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v718 = v728 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v731 : std_path_Display = v717 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v718 = v731 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v734 : std_path_Display = _v718 
                                                                                                                                                                                                    let v739 : string = v734 |> string 
                                                                                                                                                                                                    let v742 : string = method56(v739, v599)
                                                                                                                                                                                                    let v743 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v744 : string = "&*$0"
                                                                                                                                                                                                    let v745 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v742 v744 
                                                                                                                                                                                                    let _v743 = v745 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v746 : string = "&*$0"
                                                                                                                                                                                                    let v747 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v742 v746 
                                                                                                                                                                                                    let _v743 = v747 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v748 : string = "&*$0"
                                                                                                                                                                                                    let v749 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v742 v748 
                                                                                                                                                                                                    let _v743 = v749 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v750 : Ref<Str> = v742 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v743 = v750 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v753 : Ref<Str> = v742 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v743 = v753 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v756 : Ref<Str> = v742 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v743 = v756 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v759 : Ref<Str> = _v743 
                                                                                                                                                                                                    let v764 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v765 : string = "String::from($0)"
                                                                                                                                                                                                    let v766 : std_string_String = Fable.Core.RustInterop.emitRustExpr v759 v765 
                                                                                                                                                                                                    let _v764 = v766 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v767 : string = "String::from($0)"
                                                                                                                                                                                                    let v768 : std_string_String = Fable.Core.RustInterop.emitRustExpr v759 v767 
                                                                                                                                                                                                    let _v764 = v768 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v769 : string = "String::from($0)"
                                                                                                                                                                                                    let v770 : std_string_String = Fable.Core.RustInterop.emitRustExpr v759 v769 
                                                                                                                                                                                                    let _v764 = v770 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v771 : std_string_String = v759 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v764 = v771 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v774 : std_string_String = v759 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v764 = v774 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v777 : std_string_String = v759 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v764 = v777 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v780 : std_string_String = _v764 
                                                                                                                                                                                                    let v785 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v786 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v787 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v780 v786 
                                                                                                                                                                                                    let _v785 = v787 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v788 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v789 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v780 v788 
                                                                                                                                                                                                    let _v785 = v789 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v790 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v791 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v780 v790 
                                                                                                                                                                                                    let _v785 = v791 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v792 : std_path_PathBuf = v780 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v785 = v792 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v795 : std_path_PathBuf = v780 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v785 = v795 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v798 : std_path_PathBuf = v780 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v785 = v798 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v801 : std_path_PathBuf = _v785 
                                                                                                                                                                                                    let v806 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v807 : string = "Ok($0)"
                                                                                                                                                                                                    let v808 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v801 v807 
                                                                                                                                                                                                    let _v806 = v808 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v809 : string = "Ok($0)"
                                                                                                                                                                                                    let v810 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v801 v809 
                                                                                                                                                                                                    let _v806 = v810 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v811 : string = "Ok($0)"
                                                                                                                                                                                                    let v812 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v801 v811 
                                                                                                                                                                                                    let _v806 = v812 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v813 : Result<std_path_PathBuf, std_io_Error> = v801 |> Ok
                                                                                                                                                                                                    let _v806 = v813 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v814 : Result<std_path_PathBuf, std_io_Error> = v801 |> Ok
                                                                                                                                                                                                    let _v806 = v814 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v815 : Result<std_path_PathBuf, std_io_Error> = v801 |> Ok
                                                                                                                                                                                                    let _v806 = v815 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v816 : Result<std_path_PathBuf, std_io_Error> = _v806 
                                                                                                                                                                                                    v816
                                                                                                                                                                                            else
                                                                                                                                                                                                let v849 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v598} / path': {v563} / name: {v599}"
                                                                                                                                                                                                let v850 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v851 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v852 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v849 v851 
                                                                                                                                                                                                let _v850 = v852 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v853 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v854 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v849 v853 
                                                                                                                                                                                                let _v850 = v854 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v855 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v856 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v849 v855 
                                                                                                                                                                                                let _v850 = v856 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v857 : std_io_Error = v849 
                                                                                                                                                                                                let _v850 = v857 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v858 : std_io_Error = v849 
                                                                                                                                                                                                let _v850 = v858 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v859 : std_io_Error = v849 
                                                                                                                                                                                                let _v850 = v859 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v860 : std_io_Error = _v850 
                                                                                                                                                                                                let v863 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v864 : string = "Err($0)"
                                                                                                                                                                                                let v865 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v860 v864 
                                                                                                                                                                                                let _v863 = v865 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v866 : string = "Err($0)"
                                                                                                                                                                                                let v867 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v860 v866 
                                                                                                                                                                                                let _v863 = v867 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v868 : string = "Err($0)"
                                                                                                                                                                                                let v869 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v860 v868 
                                                                                                                                                                                                let _v863 = v869 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v870 : Result<std_path_PathBuf, std_io_Error> = v860 |> Error
                                                                                                                                                                                                let _v863 = v870 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v871 : Result<std_path_PathBuf, std_io_Error> = v860 |> Error
                                                                                                                                                                                                let _v863 = v871 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v872 : Result<std_path_PathBuf, std_io_Error> = v860 |> Error
                                                                                                                                                                                                let _v863 = v872 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v873 : Result<std_path_PathBuf, std_io_Error> = _v863 
                                                                                                                                                                                                v873
                                                                                                                                                                                        | _ ->
                                                                                                                                                                                            let v877 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v598} / path': {v563} / name: {v599}"
                                                                                                                                                                                            let v878 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v879 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v880 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v877 v879 
                                                                                                                                                                                            let _v878 = v880 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v881 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v882 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v877 v881 
                                                                                                                                                                                            let _v878 = v882 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v883 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v884 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v877 v883 
                                                                                                                                                                                            let _v878 = v884 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v885 : std_io_Error = v877 
                                                                                                                                                                                            let _v878 = v885 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v886 : std_io_Error = v877 
                                                                                                                                                                                            let _v878 = v886 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v887 : std_io_Error = v877 
                                                                                                                                                                                            let _v878 = v887 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v888 : std_io_Error = _v878 
                                                                                                                                                                                            let v891 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v892 : string = "Err($0)"
                                                                                                                                                                                            let v893 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v888 v892 
                                                                                                                                                                                            let _v891 = v893 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v894 : string = "Err($0)"
                                                                                                                                                                                            let v895 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v888 v894 
                                                                                                                                                                                            let _v891 = v895 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v896 : string = "Err($0)"
                                                                                                                                                                                            let v897 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v888 v896 
                                                                                                                                                                                            let _v891 = v897 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v898 : Result<std_path_PathBuf, std_io_Error> = v888 |> Error
                                                                                                                                                                                            let _v891 = v898 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v899 : Result<std_path_PathBuf, std_io_Error> = v888 |> Error
                                                                                                                                                                                            let _v891 = v899 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v900 : Result<std_path_PathBuf, std_io_Error> = v888 |> Error
                                                                                                                                                                                            let _v891 = v900 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v901 : Result<std_path_PathBuf, std_io_Error> = _v891 
                                                                                                                                                                                            v901
                                                                                                                                                                                    | US13_0(v584) -> (* Ok *)
                                                                                                                                                                                        let v585 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v586 : string = "Ok($0)"
                                                                                                                                                                                        let v587 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v584 v586 
                                                                                                                                                                                        let _v585 = v587 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v588 : string = "Ok($0)"
                                                                                                                                                                                        let v589 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v584 v588 
                                                                                                                                                                                        let _v585 = v589 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v590 : string = "Ok($0)"
                                                                                                                                                                                        let v591 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v584 v590 
                                                                                                                                                                                        let _v585 = v591 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v592 : Result<std_path_PathBuf, std_io_Error> = v584 |> Ok
                                                                                                                                                                                        let _v585 = v592 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v593 : Result<std_path_PathBuf, std_io_Error> = v584 |> Ok
                                                                                                                                                                                        let _v585 = v593 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v594 : Result<std_path_PathBuf, std_io_Error> = v584 |> Ok
                                                                                                                                                                                        let _v585 = v594 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v595 : Result<std_path_PathBuf, std_io_Error> = _v585 
                                                                                                                                                                                        v595
                                                                                                                                                                                let v907 : (std_io_Error -> string) = method76()
                                                                                                                                                                                let v908 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v909 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v910 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v906, v907) v909 
                                                                                                                                                                                let _v908 = v910 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v911 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v912 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v906, v907) v911 
                                                                                                                                                                                let _v908 = v912 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v913 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v914 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v906, v907) v913 
                                                                                                                                                                                let _v908 = v914 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v915 : Result<std_path_PathBuf, string> = match v906 with Ok x -> Ok x | Error x -> Error (v907 x)
                                                                                                                                                                                let _v908 = v915 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v916 : Result<std_path_PathBuf, string> = match v906 with Ok x -> Ok x | Error x -> Error (v907 x)
                                                                                                                                                                                let _v908 = v916 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v917 : Result<std_path_PathBuf, string> = match v906 with Ok x -> Ok x | Error x -> Error (v907 x)
                                                                                                                                                                                let _v908 = v917 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v918 : Result<std_path_PathBuf, string> = _v908 
                                                                                                                                                                                let v921 : US13 = match v918 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                                                                match v921 with
                                                                                                                                                                                | US13_1(v1024) -> (* Error *)
                                                                                                                                                                                    let v1025 : string = $"file_system.read_link / error': {v1024} / error: {v543} / name: {v544}"
                                                                                                                                                                                    let v1026 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v1027 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v1028 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1025 v1027 
                                                                                                                                                                                    let _v1026 = v1028 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v1029 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v1030 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1025 v1029 
                                                                                                                                                                                    let _v1026 = v1030 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v1031 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v1032 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1025 v1031 
                                                                                                                                                                                    let _v1026 = v1032 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v1033 : std_io_Error = v1025 
                                                                                                                                                                                    let _v1026 = v1033 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v1034 : std_io_Error = v1025 
                                                                                                                                                                                    let _v1026 = v1034 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v1035 : std_io_Error = v1025 
                                                                                                                                                                                    let _v1026 = v1035 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v1036 : std_io_Error = _v1026 
                                                                                                                                                                                    let v1039 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v1040 : string = "Err($0)"
                                                                                                                                                                                    let v1041 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1036 v1040 
                                                                                                                                                                                    let _v1039 = v1041 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v1042 : string = "Err($0)"
                                                                                                                                                                                    let v1043 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1036 v1042 
                                                                                                                                                                                    let _v1039 = v1043 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v1044 : string = "Err($0)"
                                                                                                                                                                                    let v1045 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1036 v1044 
                                                                                                                                                                                    let _v1039 = v1045 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v1046 : Result<std_path_PathBuf, std_io_Error> = v1036 |> Error
                                                                                                                                                                                    let _v1039 = v1046 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v1047 : Result<std_path_PathBuf, std_io_Error> = v1036 |> Error
                                                                                                                                                                                    let _v1039 = v1047 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v1048 : Result<std_path_PathBuf, std_io_Error> = v1036 |> Error
                                                                                                                                                                                    let _v1039 = v1048 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v1049 : Result<std_path_PathBuf, std_io_Error> = _v1039 
                                                                                                                                                                                    v1049
                                                                                                                                                                                | US13_0(v922) -> (* Ok *)
                                                                                                                                                                                    let v923 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v924 : string = "$0.display()"
                                                                                                                                                                                    let v925 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v922 v924 
                                                                                                                                                                                    let _v923 = v925 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v926 : string = "$0.display()"
                                                                                                                                                                                    let v927 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v922 v926 
                                                                                                                                                                                    let _v923 = v927 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v928 : string = "$0.display()"
                                                                                                                                                                                    let v929 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v922 v928 
                                                                                                                                                                                    let _v923 = v929 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v930 : std_path_Display = v922 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v923 = v930 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v933 : std_path_Display = v922 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v923 = v933 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v936 : std_path_Display = v922 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v923 = v936 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v939 : std_path_Display = _v923 
                                                                                                                                                                                    let v944 : string = v939 |> string 
                                                                                                                                                                                    let v947 : string = method56(v944, v544)
                                                                                                                                                                                    let v948 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v949 : string = "&*$0"
                                                                                                                                                                                    let v950 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v947 v949 
                                                                                                                                                                                    let _v948 = v950 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v951 : string = "&*$0"
                                                                                                                                                                                    let v952 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v947 v951 
                                                                                                                                                                                    let _v948 = v952 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v953 : string = "&*$0"
                                                                                                                                                                                    let v954 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v947 v953 
                                                                                                                                                                                    let _v948 = v954 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v955 : Ref<Str> = v947 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v948 = v955 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v958 : Ref<Str> = v947 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v948 = v958 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v961 : Ref<Str> = v947 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v948 = v961 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v964 : Ref<Str> = _v948 
                                                                                                                                                                                    let v969 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v970 : string = "String::from($0)"
                                                                                                                                                                                    let v971 : std_string_String = Fable.Core.RustInterop.emitRustExpr v964 v970 
                                                                                                                                                                                    let _v969 = v971 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v972 : string = "String::from($0)"
                                                                                                                                                                                    let v973 : std_string_String = Fable.Core.RustInterop.emitRustExpr v964 v972 
                                                                                                                                                                                    let _v969 = v973 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v974 : string = "String::from($0)"
                                                                                                                                                                                    let v975 : std_string_String = Fable.Core.RustInterop.emitRustExpr v964 v974 
                                                                                                                                                                                    let _v969 = v975 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v976 : std_string_String = v964 |> unbox<std_string_String>
                                                                                                                                                                                    let _v969 = v976 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v979 : std_string_String = v964 |> unbox<std_string_String>
                                                                                                                                                                                    let _v969 = v979 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v982 : std_string_String = v964 |> unbox<std_string_String>
                                                                                                                                                                                    let _v969 = v982 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v985 : std_string_String = _v969 
                                                                                                                                                                                    let v990 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v991 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v992 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v985 v991 
                                                                                                                                                                                    let _v990 = v992 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v993 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v994 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v985 v993 
                                                                                                                                                                                    let _v990 = v994 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v995 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v996 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v985 v995 
                                                                                                                                                                                    let _v990 = v996 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v997 : std_path_PathBuf = v985 |> std_path_PathBuf 
                                                                                                                                                                                    let _v990 = v997 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v1000 : std_path_PathBuf = v985 |> std_path_PathBuf 
                                                                                                                                                                                    let _v990 = v1000 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v1003 : std_path_PathBuf = v985 |> std_path_PathBuf 
                                                                                                                                                                                    let _v990 = v1003 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v1006 : std_path_PathBuf = _v990 
                                                                                                                                                                                    let v1011 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v1012 : string = "Ok($0)"
                                                                                                                                                                                    let v1013 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1006 v1012 
                                                                                                                                                                                    let _v1011 = v1013 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v1014 : string = "Ok($0)"
                                                                                                                                                                                    let v1015 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1006 v1014 
                                                                                                                                                                                    let _v1011 = v1015 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v1016 : string = "Ok($0)"
                                                                                                                                                                                    let v1017 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1006 v1016 
                                                                                                                                                                                    let _v1011 = v1017 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v1018 : Result<std_path_PathBuf, std_io_Error> = v1006 |> Ok
                                                                                                                                                                                    let _v1011 = v1018 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v1019 : Result<std_path_PathBuf, std_io_Error> = v1006 |> Ok
                                                                                                                                                                                    let _v1011 = v1019 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v1020 : Result<std_path_PathBuf, std_io_Error> = v1006 |> Ok
                                                                                                                                                                                    let _v1011 = v1020 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v1021 : Result<std_path_PathBuf, std_io_Error> = _v1011 
                                                                                                                                                                                    v1021
                                                                                                                                                                            else
                                                                                                                                                                                let v1054 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v543} / path': {v508} / name: {v544}"
                                                                                                                                                                                let v1055 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v1056 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v1057 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1054 v1056 
                                                                                                                                                                                let _v1055 = v1057 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v1058 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v1059 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1054 v1058 
                                                                                                                                                                                let _v1055 = v1059 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v1060 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v1061 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1054 v1060 
                                                                                                                                                                                let _v1055 = v1061 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v1062 : std_io_Error = v1054 
                                                                                                                                                                                let _v1055 = v1062 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v1063 : std_io_Error = v1054 
                                                                                                                                                                                let _v1055 = v1063 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v1064 : std_io_Error = v1054 
                                                                                                                                                                                let _v1055 = v1064 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v1065 : std_io_Error = _v1055 
                                                                                                                                                                                let v1068 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v1069 : string = "Err($0)"
                                                                                                                                                                                let v1070 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1065 v1069 
                                                                                                                                                                                let _v1068 = v1070 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v1071 : string = "Err($0)"
                                                                                                                                                                                let v1072 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1065 v1071 
                                                                                                                                                                                let _v1068 = v1072 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v1073 : string = "Err($0)"
                                                                                                                                                                                let v1074 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1065 v1073 
                                                                                                                                                                                let _v1068 = v1074 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v1075 : Result<std_path_PathBuf, std_io_Error> = v1065 |> Error
                                                                                                                                                                                let _v1068 = v1075 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v1076 : Result<std_path_PathBuf, std_io_Error> = v1065 |> Error
                                                                                                                                                                                let _v1068 = v1076 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v1077 : Result<std_path_PathBuf, std_io_Error> = v1065 |> Error
                                                                                                                                                                                let _v1068 = v1077 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v1078 : Result<std_path_PathBuf, std_io_Error> = _v1068 
                                                                                                                                                                                v1078
                                                                                                                                                                        | _ ->
                                                                                                                                                                            let v1082 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v543} / path': {v508} / name: {v544}"
                                                                                                                                                                            let v1083 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v1084 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v1085 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1082 v1084 
                                                                                                                                                                            let _v1083 = v1085 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v1086 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v1087 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1082 v1086 
                                                                                                                                                                            let _v1083 = v1087 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v1088 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v1089 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1082 v1088 
                                                                                                                                                                            let _v1083 = v1089 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v1090 : std_io_Error = v1082 
                                                                                                                                                                            let _v1083 = v1090 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v1091 : std_io_Error = v1082 
                                                                                                                                                                            let _v1083 = v1091 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v1092 : std_io_Error = v1082 
                                                                                                                                                                            let _v1083 = v1092 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v1093 : std_io_Error = _v1083 
                                                                                                                                                                            let v1096 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v1097 : string = "Err($0)"
                                                                                                                                                                            let v1098 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1093 v1097 
                                                                                                                                                                            let _v1096 = v1098 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v1099 : string = "Err($0)"
                                                                                                                                                                            let v1100 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1093 v1099 
                                                                                                                                                                            let _v1096 = v1100 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v1101 : string = "Err($0)"
                                                                                                                                                                            let v1102 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1093 v1101 
                                                                                                                                                                            let _v1096 = v1102 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v1103 : Result<std_path_PathBuf, std_io_Error> = v1093 |> Error
                                                                                                                                                                            let _v1096 = v1103 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v1104 : Result<std_path_PathBuf, std_io_Error> = v1093 |> Error
                                                                                                                                                                            let _v1096 = v1104 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v1105 : Result<std_path_PathBuf, std_io_Error> = v1093 |> Error
                                                                                                                                                                            let _v1096 = v1105 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v1106 : Result<std_path_PathBuf, std_io_Error> = _v1096 
                                                                                                                                                                            v1106
                                                                                                                                                                    | US13_0(v529) -> (* Ok *)
                                                                                                                                                                        let v530 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v531 : string = "Ok($0)"
                                                                                                                                                                        let v532 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v529 v531 
                                                                                                                                                                        let _v530 = v532 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v533 : string = "Ok($0)"
                                                                                                                                                                        let v534 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v529 v533 
                                                                                                                                                                        let _v530 = v534 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v535 : string = "Ok($0)"
                                                                                                                                                                        let v536 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v529 v535 
                                                                                                                                                                        let _v530 = v536 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v537 : Result<std_path_PathBuf, std_io_Error> = v529 |> Ok
                                                                                                                                                                        let _v530 = v537 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v538 : Result<std_path_PathBuf, std_io_Error> = v529 |> Ok
                                                                                                                                                                        let _v530 = v538 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v539 : Result<std_path_PathBuf, std_io_Error> = v529 |> Ok
                                                                                                                                                                        let _v530 = v539 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v540 : Result<std_path_PathBuf, std_io_Error> = _v530 
                                                                                                                                                                        v540
                                                                                                                                                                let v1112 : (std_io_Error -> string) = method76()
                                                                                                                                                                let v1113 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1114 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v1115 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1111, v1112) v1114 
                                                                                                                                                                let _v1113 = v1115 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1116 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v1117 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1111, v1112) v1116 
                                                                                                                                                                let _v1113 = v1117 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1118 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v1119 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1111, v1112) v1118 
                                                                                                                                                                let _v1113 = v1119 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1120 : Result<std_path_PathBuf, string> = match v1111 with Ok x -> Ok x | Error x -> Error (v1112 x)
                                                                                                                                                                let _v1113 = v1120 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1121 : Result<std_path_PathBuf, string> = match v1111 with Ok x -> Ok x | Error x -> Error (v1112 x)
                                                                                                                                                                let _v1113 = v1121 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1122 : Result<std_path_PathBuf, string> = match v1111 with Ok x -> Ok x | Error x -> Error (v1112 x)
                                                                                                                                                                let _v1113 = v1122 
                                                                                                                                                                #endif
                                                                                                                                                                let v1123 : Result<std_path_PathBuf, string> = _v1113 
                                                                                                                                                                let v1126 : US13 = match v1123 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                                                match v1126 with
                                                                                                                                                                | US13_1(v1229) -> (* Error *)
                                                                                                                                                                    let v1230 : string = $"file_system.read_link / error': {v1229} / error: {v488} / name: {v489}"
                                                                                                                                                                    let v1231 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v1232 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v1233 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1230 v1232 
                                                                                                                                                                    let _v1231 = v1233 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v1234 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v1235 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1230 v1234 
                                                                                                                                                                    let _v1231 = v1235 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v1236 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v1237 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1230 v1236 
                                                                                                                                                                    let _v1231 = v1237 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v1238 : std_io_Error = v1230 
                                                                                                                                                                    let _v1231 = v1238 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v1239 : std_io_Error = v1230 
                                                                                                                                                                    let _v1231 = v1239 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v1240 : std_io_Error = v1230 
                                                                                                                                                                    let _v1231 = v1240 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v1241 : std_io_Error = _v1231 
                                                                                                                                                                    let v1244 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v1245 : string = "Err($0)"
                                                                                                                                                                    let v1246 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1241 v1245 
                                                                                                                                                                    let _v1244 = v1246 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v1247 : string = "Err($0)"
                                                                                                                                                                    let v1248 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1241 v1247 
                                                                                                                                                                    let _v1244 = v1248 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v1249 : string = "Err($0)"
                                                                                                                                                                    let v1250 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1241 v1249 
                                                                                                                                                                    let _v1244 = v1250 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v1251 : Result<std_path_PathBuf, std_io_Error> = v1241 |> Error
                                                                                                                                                                    let _v1244 = v1251 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v1252 : Result<std_path_PathBuf, std_io_Error> = v1241 |> Error
                                                                                                                                                                    let _v1244 = v1252 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v1253 : Result<std_path_PathBuf, std_io_Error> = v1241 |> Error
                                                                                                                                                                    let _v1244 = v1253 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v1254 : Result<std_path_PathBuf, std_io_Error> = _v1244 
                                                                                                                                                                    v1254
                                                                                                                                                                | US13_0(v1127) -> (* Ok *)
                                                                                                                                                                    let v1128 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v1129 : string = "$0.display()"
                                                                                                                                                                    let v1130 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1127 v1129 
                                                                                                                                                                    let _v1128 = v1130 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v1131 : string = "$0.display()"
                                                                                                                                                                    let v1132 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1127 v1131 
                                                                                                                                                                    let _v1128 = v1132 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v1133 : string = "$0.display()"
                                                                                                                                                                    let v1134 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1127 v1133 
                                                                                                                                                                    let _v1128 = v1134 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v1135 : std_path_Display = v1127 |> unbox<std_path_Display>
                                                                                                                                                                    let _v1128 = v1135 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v1138 : std_path_Display = v1127 |> unbox<std_path_Display>
                                                                                                                                                                    let _v1128 = v1138 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v1141 : std_path_Display = v1127 |> unbox<std_path_Display>
                                                                                                                                                                    let _v1128 = v1141 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v1144 : std_path_Display = _v1128 
                                                                                                                                                                    let v1149 : string = v1144 |> string 
                                                                                                                                                                    let v1152 : string = method56(v1149, v489)
                                                                                                                                                                    let v1153 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v1154 : string = "&*$0"
                                                                                                                                                                    let v1155 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1152 v1154 
                                                                                                                                                                    let _v1153 = v1155 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v1156 : string = "&*$0"
                                                                                                                                                                    let v1157 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1152 v1156 
                                                                                                                                                                    let _v1153 = v1157 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v1158 : string = "&*$0"
                                                                                                                                                                    let v1159 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1152 v1158 
                                                                                                                                                                    let _v1153 = v1159 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v1160 : Ref<Str> = v1152 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v1153 = v1160 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v1163 : Ref<Str> = v1152 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v1153 = v1163 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v1166 : Ref<Str> = v1152 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v1153 = v1166 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v1169 : Ref<Str> = _v1153 
                                                                                                                                                                    let v1174 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v1175 : string = "String::from($0)"
                                                                                                                                                                    let v1176 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1169 v1175 
                                                                                                                                                                    let _v1174 = v1176 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v1177 : string = "String::from($0)"
                                                                                                                                                                    let v1178 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1169 v1177 
                                                                                                                                                                    let _v1174 = v1178 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v1179 : string = "String::from($0)"
                                                                                                                                                                    let v1180 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1169 v1179 
                                                                                                                                                                    let _v1174 = v1180 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v1181 : std_string_String = v1169 |> unbox<std_string_String>
                                                                                                                                                                    let _v1174 = v1181 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v1184 : std_string_String = v1169 |> unbox<std_string_String>
                                                                                                                                                                    let _v1174 = v1184 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v1187 : std_string_String = v1169 |> unbox<std_string_String>
                                                                                                                                                                    let _v1174 = v1187 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v1190 : std_string_String = _v1174 
                                                                                                                                                                    let v1195 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v1196 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v1197 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1190 v1196 
                                                                                                                                                                    let _v1195 = v1197 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v1198 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v1199 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1190 v1198 
                                                                                                                                                                    let _v1195 = v1199 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v1200 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v1201 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1190 v1200 
                                                                                                                                                                    let _v1195 = v1201 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v1202 : std_path_PathBuf = v1190 |> std_path_PathBuf 
                                                                                                                                                                    let _v1195 = v1202 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v1205 : std_path_PathBuf = v1190 |> std_path_PathBuf 
                                                                                                                                                                    let _v1195 = v1205 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v1208 : std_path_PathBuf = v1190 |> std_path_PathBuf 
                                                                                                                                                                    let _v1195 = v1208 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v1211 : std_path_PathBuf = _v1195 
                                                                                                                                                                    let v1216 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v1217 : string = "Ok($0)"
                                                                                                                                                                    let v1218 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1211 v1217 
                                                                                                                                                                    let _v1216 = v1218 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v1219 : string = "Ok($0)"
                                                                                                                                                                    let v1220 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1211 v1219 
                                                                                                                                                                    let _v1216 = v1220 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v1221 : string = "Ok($0)"
                                                                                                                                                                    let v1222 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1211 v1221 
                                                                                                                                                                    let _v1216 = v1222 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v1223 : Result<std_path_PathBuf, std_io_Error> = v1211 |> Ok
                                                                                                                                                                    let _v1216 = v1223 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v1224 : Result<std_path_PathBuf, std_io_Error> = v1211 |> Ok
                                                                                                                                                                    let _v1216 = v1224 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v1225 : Result<std_path_PathBuf, std_io_Error> = v1211 |> Ok
                                                                                                                                                                    let _v1216 = v1225 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v1226 : Result<std_path_PathBuf, std_io_Error> = _v1216 
                                                                                                                                                                    v1226
                                                                                                                                                            else
                                                                                                                                                                let v1259 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v488} / path': {v453} / name: {v489}"
                                                                                                                                                                let v1260 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1261 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v1262 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1259 v1261 
                                                                                                                                                                let _v1260 = v1262 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1263 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v1264 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1259 v1263 
                                                                                                                                                                let _v1260 = v1264 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1265 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v1266 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1259 v1265 
                                                                                                                                                                let _v1260 = v1266 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1267 : std_io_Error = v1259 
                                                                                                                                                                let _v1260 = v1267 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1268 : std_io_Error = v1259 
                                                                                                                                                                let _v1260 = v1268 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1269 : std_io_Error = v1259 
                                                                                                                                                                let _v1260 = v1269 
                                                                                                                                                                #endif
                                                                                                                                                                let v1270 : std_io_Error = _v1260 
                                                                                                                                                                let v1273 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v1274 : string = "Err($0)"
                                                                                                                                                                let v1275 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1270 v1274 
                                                                                                                                                                let _v1273 = v1275 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v1276 : string = "Err($0)"
                                                                                                                                                                let v1277 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1270 v1276 
                                                                                                                                                                let _v1273 = v1277 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v1278 : string = "Err($0)"
                                                                                                                                                                let v1279 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1270 v1278 
                                                                                                                                                                let _v1273 = v1279 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v1280 : Result<std_path_PathBuf, std_io_Error> = v1270 |> Error
                                                                                                                                                                let _v1273 = v1280 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v1281 : Result<std_path_PathBuf, std_io_Error> = v1270 |> Error
                                                                                                                                                                let _v1273 = v1281 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v1282 : Result<std_path_PathBuf, std_io_Error> = v1270 |> Error
                                                                                                                                                                let _v1273 = v1282 
                                                                                                                                                                #endif
                                                                                                                                                                let v1283 : Result<std_path_PathBuf, std_io_Error> = _v1273 
                                                                                                                                                                v1283
                                                                                                                                                        | _ ->
                                                                                                                                                            let v1287 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v488} / path': {v453} / name: {v489}"
                                                                                                                                                            let v1288 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v1289 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v1290 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1287 v1289 
                                                                                                                                                            let _v1288 = v1290 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v1291 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v1292 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1287 v1291 
                                                                                                                                                            let _v1288 = v1292 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v1293 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v1294 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1287 v1293 
                                                                                                                                                            let _v1288 = v1294 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v1295 : std_io_Error = v1287 
                                                                                                                                                            let _v1288 = v1295 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v1296 : std_io_Error = v1287 
                                                                                                                                                            let _v1288 = v1296 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v1297 : std_io_Error = v1287 
                                                                                                                                                            let _v1288 = v1297 
                                                                                                                                                            #endif
                                                                                                                                                            let v1298 : std_io_Error = _v1288 
                                                                                                                                                            let v1301 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v1302 : string = "Err($0)"
                                                                                                                                                            let v1303 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1298 v1302 
                                                                                                                                                            let _v1301 = v1303 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v1304 : string = "Err($0)"
                                                                                                                                                            let v1305 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1298 v1304 
                                                                                                                                                            let _v1301 = v1305 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v1306 : string = "Err($0)"
                                                                                                                                                            let v1307 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1298 v1306 
                                                                                                                                                            let _v1301 = v1307 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v1308 : Result<std_path_PathBuf, std_io_Error> = v1298 |> Error
                                                                                                                                                            let _v1301 = v1308 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v1309 : Result<std_path_PathBuf, std_io_Error> = v1298 |> Error
                                                                                                                                                            let _v1301 = v1309 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v1310 : Result<std_path_PathBuf, std_io_Error> = v1298 |> Error
                                                                                                                                                            let _v1301 = v1310 
                                                                                                                                                            #endif
                                                                                                                                                            let v1311 : Result<std_path_PathBuf, std_io_Error> = _v1301 
                                                                                                                                                            v1311
                                                                                                                                                    | US13_0(v474) -> (* Ok *)
                                                                                                                                                        let v475 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v476 : string = "Ok($0)"
                                                                                                                                                        let v477 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v474 v476 
                                                                                                                                                        let _v475 = v477 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v478 : string = "Ok($0)"
                                                                                                                                                        let v479 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v474 v478 
                                                                                                                                                        let _v475 = v479 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v480 : string = "Ok($0)"
                                                                                                                                                        let v481 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v474 v480 
                                                                                                                                                        let _v475 = v481 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v482 : Result<std_path_PathBuf, std_io_Error> = v474 |> Ok
                                                                                                                                                        let _v475 = v482 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v483 : Result<std_path_PathBuf, std_io_Error> = v474 |> Ok
                                                                                                                                                        let _v475 = v483 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v484 : Result<std_path_PathBuf, std_io_Error> = v474 |> Ok
                                                                                                                                                        let _v475 = v484 
                                                                                                                                                        #endif
                                                                                                                                                        let v485 : Result<std_path_PathBuf, std_io_Error> = _v475 
                                                                                                                                                        v485
                                                                                                                                                let v1317 : (std_io_Error -> string) = method76()
                                                                                                                                                let v1318 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1319 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v1320 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1316, v1317) v1319 
                                                                                                                                                let _v1318 = v1320 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1321 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v1322 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1316, v1317) v1321 
                                                                                                                                                let _v1318 = v1322 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1323 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v1324 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1316, v1317) v1323 
                                                                                                                                                let _v1318 = v1324 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1325 : Result<std_path_PathBuf, string> = match v1316 with Ok x -> Ok x | Error x -> Error (v1317 x)
                                                                                                                                                let _v1318 = v1325 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1326 : Result<std_path_PathBuf, string> = match v1316 with Ok x -> Ok x | Error x -> Error (v1317 x)
                                                                                                                                                let _v1318 = v1326 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1327 : Result<std_path_PathBuf, string> = match v1316 with Ok x -> Ok x | Error x -> Error (v1317 x)
                                                                                                                                                let _v1318 = v1327 
                                                                                                                                                #endif
                                                                                                                                                let v1328 : Result<std_path_PathBuf, string> = _v1318 
                                                                                                                                                let v1331 : US13 = match v1328 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                                match v1331 with
                                                                                                                                                | US13_1(v1434) -> (* Error *)
                                                                                                                                                    let v1435 : string = $"file_system.read_link / error': {v1434} / error: {v433} / name: {v434}"
                                                                                                                                                    let v1436 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v1437 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v1438 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1435 v1437 
                                                                                                                                                    let _v1436 = v1438 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v1439 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v1440 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1435 v1439 
                                                                                                                                                    let _v1436 = v1440 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v1441 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v1442 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1435 v1441 
                                                                                                                                                    let _v1436 = v1442 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v1443 : std_io_Error = v1435 
                                                                                                                                                    let _v1436 = v1443 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v1444 : std_io_Error = v1435 
                                                                                                                                                    let _v1436 = v1444 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v1445 : std_io_Error = v1435 
                                                                                                                                                    let _v1436 = v1445 
                                                                                                                                                    #endif
                                                                                                                                                    let v1446 : std_io_Error = _v1436 
                                                                                                                                                    let v1449 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v1450 : string = "Err($0)"
                                                                                                                                                    let v1451 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1446 v1450 
                                                                                                                                                    let _v1449 = v1451 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v1452 : string = "Err($0)"
                                                                                                                                                    let v1453 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1446 v1452 
                                                                                                                                                    let _v1449 = v1453 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v1454 : string = "Err($0)"
                                                                                                                                                    let v1455 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1446 v1454 
                                                                                                                                                    let _v1449 = v1455 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v1456 : Result<std_path_PathBuf, std_io_Error> = v1446 |> Error
                                                                                                                                                    let _v1449 = v1456 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v1457 : Result<std_path_PathBuf, std_io_Error> = v1446 |> Error
                                                                                                                                                    let _v1449 = v1457 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v1458 : Result<std_path_PathBuf, std_io_Error> = v1446 |> Error
                                                                                                                                                    let _v1449 = v1458 
                                                                                                                                                    #endif
                                                                                                                                                    let v1459 : Result<std_path_PathBuf, std_io_Error> = _v1449 
                                                                                                                                                    v1459
                                                                                                                                                | US13_0(v1332) -> (* Ok *)
                                                                                                                                                    let v1333 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v1334 : string = "$0.display()"
                                                                                                                                                    let v1335 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1332 v1334 
                                                                                                                                                    let _v1333 = v1335 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v1336 : string = "$0.display()"
                                                                                                                                                    let v1337 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1332 v1336 
                                                                                                                                                    let _v1333 = v1337 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v1338 : string = "$0.display()"
                                                                                                                                                    let v1339 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1332 v1338 
                                                                                                                                                    let _v1333 = v1339 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v1340 : std_path_Display = v1332 |> unbox<std_path_Display>
                                                                                                                                                    let _v1333 = v1340 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v1343 : std_path_Display = v1332 |> unbox<std_path_Display>
                                                                                                                                                    let _v1333 = v1343 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v1346 : std_path_Display = v1332 |> unbox<std_path_Display>
                                                                                                                                                    let _v1333 = v1346 
                                                                                                                                                    #endif
                                                                                                                                                    let v1349 : std_path_Display = _v1333 
                                                                                                                                                    let v1354 : string = v1349 |> string 
                                                                                                                                                    let v1357 : string = method56(v1354, v434)
                                                                                                                                                    let v1358 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v1359 : string = "&*$0"
                                                                                                                                                    let v1360 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1357 v1359 
                                                                                                                                                    let _v1358 = v1360 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v1361 : string = "&*$0"
                                                                                                                                                    let v1362 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1357 v1361 
                                                                                                                                                    let _v1358 = v1362 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v1363 : string = "&*$0"
                                                                                                                                                    let v1364 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1357 v1363 
                                                                                                                                                    let _v1358 = v1364 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v1365 : Ref<Str> = v1357 |> unbox<Ref<Str>>
                                                                                                                                                    let _v1358 = v1365 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v1368 : Ref<Str> = v1357 |> unbox<Ref<Str>>
                                                                                                                                                    let _v1358 = v1368 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v1371 : Ref<Str> = v1357 |> unbox<Ref<Str>>
                                                                                                                                                    let _v1358 = v1371 
                                                                                                                                                    #endif
                                                                                                                                                    let v1374 : Ref<Str> = _v1358 
                                                                                                                                                    let v1379 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v1380 : string = "String::from($0)"
                                                                                                                                                    let v1381 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1374 v1380 
                                                                                                                                                    let _v1379 = v1381 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v1382 : string = "String::from($0)"
                                                                                                                                                    let v1383 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1374 v1382 
                                                                                                                                                    let _v1379 = v1383 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v1384 : string = "String::from($0)"
                                                                                                                                                    let v1385 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1374 v1384 
                                                                                                                                                    let _v1379 = v1385 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v1386 : std_string_String = v1374 |> unbox<std_string_String>
                                                                                                                                                    let _v1379 = v1386 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v1389 : std_string_String = v1374 |> unbox<std_string_String>
                                                                                                                                                    let _v1379 = v1389 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v1392 : std_string_String = v1374 |> unbox<std_string_String>
                                                                                                                                                    let _v1379 = v1392 
                                                                                                                                                    #endif
                                                                                                                                                    let v1395 : std_string_String = _v1379 
                                                                                                                                                    let v1400 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v1401 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v1402 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1395 v1401 
                                                                                                                                                    let _v1400 = v1402 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v1403 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v1404 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1395 v1403 
                                                                                                                                                    let _v1400 = v1404 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v1405 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v1406 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1395 v1405 
                                                                                                                                                    let _v1400 = v1406 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v1407 : std_path_PathBuf = v1395 |> std_path_PathBuf 
                                                                                                                                                    let _v1400 = v1407 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v1410 : std_path_PathBuf = v1395 |> std_path_PathBuf 
                                                                                                                                                    let _v1400 = v1410 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v1413 : std_path_PathBuf = v1395 |> std_path_PathBuf 
                                                                                                                                                    let _v1400 = v1413 
                                                                                                                                                    #endif
                                                                                                                                                    let v1416 : std_path_PathBuf = _v1400 
                                                                                                                                                    let v1421 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v1422 : string = "Ok($0)"
                                                                                                                                                    let v1423 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1416 v1422 
                                                                                                                                                    let _v1421 = v1423 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v1424 : string = "Ok($0)"
                                                                                                                                                    let v1425 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1416 v1424 
                                                                                                                                                    let _v1421 = v1425 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v1426 : string = "Ok($0)"
                                                                                                                                                    let v1427 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1416 v1426 
                                                                                                                                                    let _v1421 = v1427 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v1428 : Result<std_path_PathBuf, std_io_Error> = v1416 |> Ok
                                                                                                                                                    let _v1421 = v1428 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v1429 : Result<std_path_PathBuf, std_io_Error> = v1416 |> Ok
                                                                                                                                                    let _v1421 = v1429 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v1430 : Result<std_path_PathBuf, std_io_Error> = v1416 |> Ok
                                                                                                                                                    let _v1421 = v1430 
                                                                                                                                                    #endif
                                                                                                                                                    let v1431 : Result<std_path_PathBuf, std_io_Error> = _v1421 
                                                                                                                                                    v1431
                                                                                                                                            else
                                                                                                                                                let v1464 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v433} / path': {v398} / name: {v434}"
                                                                                                                                                let v1465 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1466 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v1467 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1464 v1466 
                                                                                                                                                let _v1465 = v1467 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1468 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v1469 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1464 v1468 
                                                                                                                                                let _v1465 = v1469 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1470 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v1471 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1464 v1470 
                                                                                                                                                let _v1465 = v1471 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1472 : std_io_Error = v1464 
                                                                                                                                                let _v1465 = v1472 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1473 : std_io_Error = v1464 
                                                                                                                                                let _v1465 = v1473 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1474 : std_io_Error = v1464 
                                                                                                                                                let _v1465 = v1474 
                                                                                                                                                #endif
                                                                                                                                                let v1475 : std_io_Error = _v1465 
                                                                                                                                                let v1478 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v1479 : string = "Err($0)"
                                                                                                                                                let v1480 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1475 v1479 
                                                                                                                                                let _v1478 = v1480 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v1481 : string = "Err($0)"
                                                                                                                                                let v1482 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1475 v1481 
                                                                                                                                                let _v1478 = v1482 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v1483 : string = "Err($0)"
                                                                                                                                                let v1484 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1475 v1483 
                                                                                                                                                let _v1478 = v1484 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v1485 : Result<std_path_PathBuf, std_io_Error> = v1475 |> Error
                                                                                                                                                let _v1478 = v1485 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v1486 : Result<std_path_PathBuf, std_io_Error> = v1475 |> Error
                                                                                                                                                let _v1478 = v1486 
                                                                                                                                                #endif
#else
                                                                                                                                                let v1487 : Result<std_path_PathBuf, std_io_Error> = v1475 |> Error
                                                                                                                                                let _v1478 = v1487 
                                                                                                                                                #endif
                                                                                                                                                let v1488 : Result<std_path_PathBuf, std_io_Error> = _v1478 
                                                                                                                                                v1488
                                                                                                                                        | _ ->
                                                                                                                                            let v1492 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v433} / path': {v398} / name: {v434}"
                                                                                                                                            let v1493 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v1494 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v1495 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1492 v1494 
                                                                                                                                            let _v1493 = v1495 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v1496 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v1497 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1492 v1496 
                                                                                                                                            let _v1493 = v1497 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v1498 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v1499 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1492 v1498 
                                                                                                                                            let _v1493 = v1499 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v1500 : std_io_Error = v1492 
                                                                                                                                            let _v1493 = v1500 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v1501 : std_io_Error = v1492 
                                                                                                                                            let _v1493 = v1501 
                                                                                                                                            #endif
#else
                                                                                                                                            let v1502 : std_io_Error = v1492 
                                                                                                                                            let _v1493 = v1502 
                                                                                                                                            #endif
                                                                                                                                            let v1503 : std_io_Error = _v1493 
                                                                                                                                            let v1506 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v1507 : string = "Err($0)"
                                                                                                                                            let v1508 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1503 v1507 
                                                                                                                                            let _v1506 = v1508 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v1509 : string = "Err($0)"
                                                                                                                                            let v1510 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1503 v1509 
                                                                                                                                            let _v1506 = v1510 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v1511 : string = "Err($0)"
                                                                                                                                            let v1512 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1503 v1511 
                                                                                                                                            let _v1506 = v1512 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v1513 : Result<std_path_PathBuf, std_io_Error> = v1503 |> Error
                                                                                                                                            let _v1506 = v1513 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v1514 : Result<std_path_PathBuf, std_io_Error> = v1503 |> Error
                                                                                                                                            let _v1506 = v1514 
                                                                                                                                            #endif
#else
                                                                                                                                            let v1515 : Result<std_path_PathBuf, std_io_Error> = v1503 |> Error
                                                                                                                                            let _v1506 = v1515 
                                                                                                                                            #endif
                                                                                                                                            let v1516 : Result<std_path_PathBuf, std_io_Error> = _v1506 
                                                                                                                                            v1516
                                                                                                                                    | US13_0(v419) -> (* Ok *)
                                                                                                                                        let v420 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v421 : string = "Ok($0)"
                                                                                                                                        let v422 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v419 v421 
                                                                                                                                        let _v420 = v422 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v423 : string = "Ok($0)"
                                                                                                                                        let v424 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v419 v423 
                                                                                                                                        let _v420 = v424 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v425 : string = "Ok($0)"
                                                                                                                                        let v426 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v419 v425 
                                                                                                                                        let _v420 = v426 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v427 : Result<std_path_PathBuf, std_io_Error> = v419 |> Ok
                                                                                                                                        let _v420 = v427 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v428 : Result<std_path_PathBuf, std_io_Error> = v419 |> Ok
                                                                                                                                        let _v420 = v428 
                                                                                                                                        #endif
#else
                                                                                                                                        let v429 : Result<std_path_PathBuf, std_io_Error> = v419 |> Ok
                                                                                                                                        let _v420 = v429 
                                                                                                                                        #endif
                                                                                                                                        let v430 : Result<std_path_PathBuf, std_io_Error> = _v420 
                                                                                                                                        v430
                                                                                                                                let v1522 : (std_io_Error -> string) = method76()
                                                                                                                                let v1523 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1524 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v1525 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1521, v1522) v1524 
                                                                                                                                let _v1523 = v1525 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1526 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v1527 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1521, v1522) v1526 
                                                                                                                                let _v1523 = v1527 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1528 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v1529 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1521, v1522) v1528 
                                                                                                                                let _v1523 = v1529 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1530 : Result<std_path_PathBuf, string> = match v1521 with Ok x -> Ok x | Error x -> Error (v1522 x)
                                                                                                                                let _v1523 = v1530 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1531 : Result<std_path_PathBuf, string> = match v1521 with Ok x -> Ok x | Error x -> Error (v1522 x)
                                                                                                                                let _v1523 = v1531 
                                                                                                                                #endif
#else
                                                                                                                                let v1532 : Result<std_path_PathBuf, string> = match v1521 with Ok x -> Ok x | Error x -> Error (v1522 x)
                                                                                                                                let _v1523 = v1532 
                                                                                                                                #endif
                                                                                                                                let v1533 : Result<std_path_PathBuf, string> = _v1523 
                                                                                                                                let v1536 : US13 = match v1533 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                                match v1536 with
                                                                                                                                | US13_1(v1639) -> (* Error *)
                                                                                                                                    let v1640 : string = $"file_system.read_link / error': {v1639} / error: {v378} / name: {v379}"
                                                                                                                                    let v1641 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v1642 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v1643 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1640 v1642 
                                                                                                                                    let _v1641 = v1643 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v1644 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v1645 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1640 v1644 
                                                                                                                                    let _v1641 = v1645 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v1646 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v1647 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1640 v1646 
                                                                                                                                    let _v1641 = v1647 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v1648 : std_io_Error = v1640 
                                                                                                                                    let _v1641 = v1648 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v1649 : std_io_Error = v1640 
                                                                                                                                    let _v1641 = v1649 
                                                                                                                                    #endif
#else
                                                                                                                                    let v1650 : std_io_Error = v1640 
                                                                                                                                    let _v1641 = v1650 
                                                                                                                                    #endif
                                                                                                                                    let v1651 : std_io_Error = _v1641 
                                                                                                                                    let v1654 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v1655 : string = "Err($0)"
                                                                                                                                    let v1656 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1651 v1655 
                                                                                                                                    let _v1654 = v1656 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v1657 : string = "Err($0)"
                                                                                                                                    let v1658 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1651 v1657 
                                                                                                                                    let _v1654 = v1658 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v1659 : string = "Err($0)"
                                                                                                                                    let v1660 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1651 v1659 
                                                                                                                                    let _v1654 = v1660 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v1661 : Result<std_path_PathBuf, std_io_Error> = v1651 |> Error
                                                                                                                                    let _v1654 = v1661 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v1662 : Result<std_path_PathBuf, std_io_Error> = v1651 |> Error
                                                                                                                                    let _v1654 = v1662 
                                                                                                                                    #endif
#else
                                                                                                                                    let v1663 : Result<std_path_PathBuf, std_io_Error> = v1651 |> Error
                                                                                                                                    let _v1654 = v1663 
                                                                                                                                    #endif
                                                                                                                                    let v1664 : Result<std_path_PathBuf, std_io_Error> = _v1654 
                                                                                                                                    v1664
                                                                                                                                | US13_0(v1537) -> (* Ok *)
                                                                                                                                    let v1538 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v1539 : string = "$0.display()"
                                                                                                                                    let v1540 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1537 v1539 
                                                                                                                                    let _v1538 = v1540 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v1541 : string = "$0.display()"
                                                                                                                                    let v1542 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1537 v1541 
                                                                                                                                    let _v1538 = v1542 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v1543 : string = "$0.display()"
                                                                                                                                    let v1544 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1537 v1543 
                                                                                                                                    let _v1538 = v1544 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v1545 : std_path_Display = v1537 |> unbox<std_path_Display>
                                                                                                                                    let _v1538 = v1545 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v1548 : std_path_Display = v1537 |> unbox<std_path_Display>
                                                                                                                                    let _v1538 = v1548 
                                                                                                                                    #endif
#else
                                                                                                                                    let v1551 : std_path_Display = v1537 |> unbox<std_path_Display>
                                                                                                                                    let _v1538 = v1551 
                                                                                                                                    #endif
                                                                                                                                    let v1554 : std_path_Display = _v1538 
                                                                                                                                    let v1559 : string = v1554 |> string 
                                                                                                                                    let v1562 : string = method56(v1559, v379)
                                                                                                                                    let v1563 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v1564 : string = "&*$0"
                                                                                                                                    let v1565 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1562 v1564 
                                                                                                                                    let _v1563 = v1565 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v1566 : string = "&*$0"
                                                                                                                                    let v1567 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1562 v1566 
                                                                                                                                    let _v1563 = v1567 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v1568 : string = "&*$0"
                                                                                                                                    let v1569 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1562 v1568 
                                                                                                                                    let _v1563 = v1569 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v1570 : Ref<Str> = v1562 |> unbox<Ref<Str>>
                                                                                                                                    let _v1563 = v1570 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v1573 : Ref<Str> = v1562 |> unbox<Ref<Str>>
                                                                                                                                    let _v1563 = v1573 
                                                                                                                                    #endif
#else
                                                                                                                                    let v1576 : Ref<Str> = v1562 |> unbox<Ref<Str>>
                                                                                                                                    let _v1563 = v1576 
                                                                                                                                    #endif
                                                                                                                                    let v1579 : Ref<Str> = _v1563 
                                                                                                                                    let v1584 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v1585 : string = "String::from($0)"
                                                                                                                                    let v1586 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1579 v1585 
                                                                                                                                    let _v1584 = v1586 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v1587 : string = "String::from($0)"
                                                                                                                                    let v1588 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1579 v1587 
                                                                                                                                    let _v1584 = v1588 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v1589 : string = "String::from($0)"
                                                                                                                                    let v1590 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1579 v1589 
                                                                                                                                    let _v1584 = v1590 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v1591 : std_string_String = v1579 |> unbox<std_string_String>
                                                                                                                                    let _v1584 = v1591 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v1594 : std_string_String = v1579 |> unbox<std_string_String>
                                                                                                                                    let _v1584 = v1594 
                                                                                                                                    #endif
#else
                                                                                                                                    let v1597 : std_string_String = v1579 |> unbox<std_string_String>
                                                                                                                                    let _v1584 = v1597 
                                                                                                                                    #endif
                                                                                                                                    let v1600 : std_string_String = _v1584 
                                                                                                                                    let v1605 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v1606 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v1607 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1600 v1606 
                                                                                                                                    let _v1605 = v1607 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v1608 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v1609 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1600 v1608 
                                                                                                                                    let _v1605 = v1609 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v1610 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v1611 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1600 v1610 
                                                                                                                                    let _v1605 = v1611 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v1612 : std_path_PathBuf = v1600 |> std_path_PathBuf 
                                                                                                                                    let _v1605 = v1612 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v1615 : std_path_PathBuf = v1600 |> std_path_PathBuf 
                                                                                                                                    let _v1605 = v1615 
                                                                                                                                    #endif
#else
                                                                                                                                    let v1618 : std_path_PathBuf = v1600 |> std_path_PathBuf 
                                                                                                                                    let _v1605 = v1618 
                                                                                                                                    #endif
                                                                                                                                    let v1621 : std_path_PathBuf = _v1605 
                                                                                                                                    let v1626 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v1627 : string = "Ok($0)"
                                                                                                                                    let v1628 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1621 v1627 
                                                                                                                                    let _v1626 = v1628 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v1629 : string = "Ok($0)"
                                                                                                                                    let v1630 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1621 v1629 
                                                                                                                                    let _v1626 = v1630 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v1631 : string = "Ok($0)"
                                                                                                                                    let v1632 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1621 v1631 
                                                                                                                                    let _v1626 = v1632 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v1633 : Result<std_path_PathBuf, std_io_Error> = v1621 |> Ok
                                                                                                                                    let _v1626 = v1633 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v1634 : Result<std_path_PathBuf, std_io_Error> = v1621 |> Ok
                                                                                                                                    let _v1626 = v1634 
                                                                                                                                    #endif
#else
                                                                                                                                    let v1635 : Result<std_path_PathBuf, std_io_Error> = v1621 |> Ok
                                                                                                                                    let _v1626 = v1635 
                                                                                                                                    #endif
                                                                                                                                    let v1636 : Result<std_path_PathBuf, std_io_Error> = _v1626 
                                                                                                                                    v1636
                                                                                                                            else
                                                                                                                                let v1669 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v378} / path': {v343} / name: {v379}"
                                                                                                                                let v1670 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1671 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v1672 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1669 v1671 
                                                                                                                                let _v1670 = v1672 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1673 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v1674 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1669 v1673 
                                                                                                                                let _v1670 = v1674 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1675 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v1676 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1669 v1675 
                                                                                                                                let _v1670 = v1676 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1677 : std_io_Error = v1669 
                                                                                                                                let _v1670 = v1677 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1678 : std_io_Error = v1669 
                                                                                                                                let _v1670 = v1678 
                                                                                                                                #endif
#else
                                                                                                                                let v1679 : std_io_Error = v1669 
                                                                                                                                let _v1670 = v1679 
                                                                                                                                #endif
                                                                                                                                let v1680 : std_io_Error = _v1670 
                                                                                                                                let v1683 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v1684 : string = "Err($0)"
                                                                                                                                let v1685 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1680 v1684 
                                                                                                                                let _v1683 = v1685 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v1686 : string = "Err($0)"
                                                                                                                                let v1687 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1680 v1686 
                                                                                                                                let _v1683 = v1687 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v1688 : string = "Err($0)"
                                                                                                                                let v1689 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1680 v1688 
                                                                                                                                let _v1683 = v1689 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v1690 : Result<std_path_PathBuf, std_io_Error> = v1680 |> Error
                                                                                                                                let _v1683 = v1690 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v1691 : Result<std_path_PathBuf, std_io_Error> = v1680 |> Error
                                                                                                                                let _v1683 = v1691 
                                                                                                                                #endif
#else
                                                                                                                                let v1692 : Result<std_path_PathBuf, std_io_Error> = v1680 |> Error
                                                                                                                                let _v1683 = v1692 
                                                                                                                                #endif
                                                                                                                                let v1693 : Result<std_path_PathBuf, std_io_Error> = _v1683 
                                                                                                                                v1693
                                                                                                                        | _ ->
                                                                                                                            let v1697 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v378} / path': {v343} / name: {v379}"
                                                                                                                            let v1698 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v1699 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v1700 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1697 v1699 
                                                                                                                            let _v1698 = v1700 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v1701 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v1702 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1697 v1701 
                                                                                                                            let _v1698 = v1702 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v1703 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v1704 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1697 v1703 
                                                                                                                            let _v1698 = v1704 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v1705 : std_io_Error = v1697 
                                                                                                                            let _v1698 = v1705 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v1706 : std_io_Error = v1697 
                                                                                                                            let _v1698 = v1706 
                                                                                                                            #endif
#else
                                                                                                                            let v1707 : std_io_Error = v1697 
                                                                                                                            let _v1698 = v1707 
                                                                                                                            #endif
                                                                                                                            let v1708 : std_io_Error = _v1698 
                                                                                                                            let v1711 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v1712 : string = "Err($0)"
                                                                                                                            let v1713 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1708 v1712 
                                                                                                                            let _v1711 = v1713 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v1714 : string = "Err($0)"
                                                                                                                            let v1715 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1708 v1714 
                                                                                                                            let _v1711 = v1715 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v1716 : string = "Err($0)"
                                                                                                                            let v1717 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1708 v1716 
                                                                                                                            let _v1711 = v1717 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v1718 : Result<std_path_PathBuf, std_io_Error> = v1708 |> Error
                                                                                                                            let _v1711 = v1718 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v1719 : Result<std_path_PathBuf, std_io_Error> = v1708 |> Error
                                                                                                                            let _v1711 = v1719 
                                                                                                                            #endif
#else
                                                                                                                            let v1720 : Result<std_path_PathBuf, std_io_Error> = v1708 |> Error
                                                                                                                            let _v1711 = v1720 
                                                                                                                            #endif
                                                                                                                            let v1721 : Result<std_path_PathBuf, std_io_Error> = _v1711 
                                                                                                                            v1721
                                                                                                                    | US13_0(v364) -> (* Ok *)
                                                                                                                        let v365 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v366 : string = "Ok($0)"
                                                                                                                        let v367 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v364 v366 
                                                                                                                        let _v365 = v367 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v368 : string = "Ok($0)"
                                                                                                                        let v369 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v364 v368 
                                                                                                                        let _v365 = v369 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v370 : string = "Ok($0)"
                                                                                                                        let v371 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v364 v370 
                                                                                                                        let _v365 = v371 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v372 : Result<std_path_PathBuf, std_io_Error> = v364 |> Ok
                                                                                                                        let _v365 = v372 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v373 : Result<std_path_PathBuf, std_io_Error> = v364 |> Ok
                                                                                                                        let _v365 = v373 
                                                                                                                        #endif
#else
                                                                                                                        let v374 : Result<std_path_PathBuf, std_io_Error> = v364 |> Ok
                                                                                                                        let _v365 = v374 
                                                                                                                        #endif
                                                                                                                        let v375 : Result<std_path_PathBuf, std_io_Error> = _v365 
                                                                                                                        v375
                                                                                                                let v1727 : (std_io_Error -> string) = method76()
                                                                                                                let v1728 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1729 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v1730 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1726, v1727) v1729 
                                                                                                                let _v1728 = v1730 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1731 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v1732 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1726, v1727) v1731 
                                                                                                                let _v1728 = v1732 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1733 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v1734 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1726, v1727) v1733 
                                                                                                                let _v1728 = v1734 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1735 : Result<std_path_PathBuf, string> = match v1726 with Ok x -> Ok x | Error x -> Error (v1727 x)
                                                                                                                let _v1728 = v1735 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1736 : Result<std_path_PathBuf, string> = match v1726 with Ok x -> Ok x | Error x -> Error (v1727 x)
                                                                                                                let _v1728 = v1736 
                                                                                                                #endif
#else
                                                                                                                let v1737 : Result<std_path_PathBuf, string> = match v1726 with Ok x -> Ok x | Error x -> Error (v1727 x)
                                                                                                                let _v1728 = v1737 
                                                                                                                #endif
                                                                                                                let v1738 : Result<std_path_PathBuf, string> = _v1728 
                                                                                                                let v1741 : US13 = match v1738 with Ok x -> v30 x | Error x -> v31 x
                                                                                                                match v1741 with
                                                                                                                | US13_1(v1844) -> (* Error *)
                                                                                                                    let v1845 : string = $"file_system.read_link / error': {v1844} / error: {v323} / name: {v324}"
                                                                                                                    let v1846 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v1847 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v1848 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1845 v1847 
                                                                                                                    let _v1846 = v1848 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v1849 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v1850 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1845 v1849 
                                                                                                                    let _v1846 = v1850 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v1851 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v1852 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1845 v1851 
                                                                                                                    let _v1846 = v1852 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v1853 : std_io_Error = v1845 
                                                                                                                    let _v1846 = v1853 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v1854 : std_io_Error = v1845 
                                                                                                                    let _v1846 = v1854 
                                                                                                                    #endif
#else
                                                                                                                    let v1855 : std_io_Error = v1845 
                                                                                                                    let _v1846 = v1855 
                                                                                                                    #endif
                                                                                                                    let v1856 : std_io_Error = _v1846 
                                                                                                                    let v1859 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v1860 : string = "Err($0)"
                                                                                                                    let v1861 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1856 v1860 
                                                                                                                    let _v1859 = v1861 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v1862 : string = "Err($0)"
                                                                                                                    let v1863 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1856 v1862 
                                                                                                                    let _v1859 = v1863 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v1864 : string = "Err($0)"
                                                                                                                    let v1865 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1856 v1864 
                                                                                                                    let _v1859 = v1865 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v1866 : Result<std_path_PathBuf, std_io_Error> = v1856 |> Error
                                                                                                                    let _v1859 = v1866 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v1867 : Result<std_path_PathBuf, std_io_Error> = v1856 |> Error
                                                                                                                    let _v1859 = v1867 
                                                                                                                    #endif
#else
                                                                                                                    let v1868 : Result<std_path_PathBuf, std_io_Error> = v1856 |> Error
                                                                                                                    let _v1859 = v1868 
                                                                                                                    #endif
                                                                                                                    let v1869 : Result<std_path_PathBuf, std_io_Error> = _v1859 
                                                                                                                    v1869
                                                                                                                | US13_0(v1742) -> (* Ok *)
                                                                                                                    let v1743 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v1744 : string = "$0.display()"
                                                                                                                    let v1745 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1742 v1744 
                                                                                                                    let _v1743 = v1745 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v1746 : string = "$0.display()"
                                                                                                                    let v1747 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1742 v1746 
                                                                                                                    let _v1743 = v1747 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v1748 : string = "$0.display()"
                                                                                                                    let v1749 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1742 v1748 
                                                                                                                    let _v1743 = v1749 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v1750 : std_path_Display = v1742 |> unbox<std_path_Display>
                                                                                                                    let _v1743 = v1750 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v1753 : std_path_Display = v1742 |> unbox<std_path_Display>
                                                                                                                    let _v1743 = v1753 
                                                                                                                    #endif
#else
                                                                                                                    let v1756 : std_path_Display = v1742 |> unbox<std_path_Display>
                                                                                                                    let _v1743 = v1756 
                                                                                                                    #endif
                                                                                                                    let v1759 : std_path_Display = _v1743 
                                                                                                                    let v1764 : string = v1759 |> string 
                                                                                                                    let v1767 : string = method56(v1764, v324)
                                                                                                                    let v1768 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v1769 : string = "&*$0"
                                                                                                                    let v1770 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1767 v1769 
                                                                                                                    let _v1768 = v1770 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v1771 : string = "&*$0"
                                                                                                                    let v1772 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1767 v1771 
                                                                                                                    let _v1768 = v1772 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v1773 : string = "&*$0"
                                                                                                                    let v1774 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1767 v1773 
                                                                                                                    let _v1768 = v1774 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v1775 : Ref<Str> = v1767 |> unbox<Ref<Str>>
                                                                                                                    let _v1768 = v1775 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v1778 : Ref<Str> = v1767 |> unbox<Ref<Str>>
                                                                                                                    let _v1768 = v1778 
                                                                                                                    #endif
#else
                                                                                                                    let v1781 : Ref<Str> = v1767 |> unbox<Ref<Str>>
                                                                                                                    let _v1768 = v1781 
                                                                                                                    #endif
                                                                                                                    let v1784 : Ref<Str> = _v1768 
                                                                                                                    let v1789 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v1790 : string = "String::from($0)"
                                                                                                                    let v1791 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1784 v1790 
                                                                                                                    let _v1789 = v1791 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v1792 : string = "String::from($0)"
                                                                                                                    let v1793 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1784 v1792 
                                                                                                                    let _v1789 = v1793 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v1794 : string = "String::from($0)"
                                                                                                                    let v1795 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1784 v1794 
                                                                                                                    let _v1789 = v1795 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v1796 : std_string_String = v1784 |> unbox<std_string_String>
                                                                                                                    let _v1789 = v1796 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v1799 : std_string_String = v1784 |> unbox<std_string_String>
                                                                                                                    let _v1789 = v1799 
                                                                                                                    #endif
#else
                                                                                                                    let v1802 : std_string_String = v1784 |> unbox<std_string_String>
                                                                                                                    let _v1789 = v1802 
                                                                                                                    #endif
                                                                                                                    let v1805 : std_string_String = _v1789 
                                                                                                                    let v1810 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v1811 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v1812 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1805 v1811 
                                                                                                                    let _v1810 = v1812 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v1813 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v1814 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1805 v1813 
                                                                                                                    let _v1810 = v1814 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v1815 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v1816 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v1805 v1815 
                                                                                                                    let _v1810 = v1816 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v1817 : std_path_PathBuf = v1805 |> std_path_PathBuf 
                                                                                                                    let _v1810 = v1817 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v1820 : std_path_PathBuf = v1805 |> std_path_PathBuf 
                                                                                                                    let _v1810 = v1820 
                                                                                                                    #endif
#else
                                                                                                                    let v1823 : std_path_PathBuf = v1805 |> std_path_PathBuf 
                                                                                                                    let _v1810 = v1823 
                                                                                                                    #endif
                                                                                                                    let v1826 : std_path_PathBuf = _v1810 
                                                                                                                    let v1831 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v1832 : string = "Ok($0)"
                                                                                                                    let v1833 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1826 v1832 
                                                                                                                    let _v1831 = v1833 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v1834 : string = "Ok($0)"
                                                                                                                    let v1835 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1826 v1834 
                                                                                                                    let _v1831 = v1835 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v1836 : string = "Ok($0)"
                                                                                                                    let v1837 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1826 v1836 
                                                                                                                    let _v1831 = v1837 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v1838 : Result<std_path_PathBuf, std_io_Error> = v1826 |> Ok
                                                                                                                    let _v1831 = v1838 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v1839 : Result<std_path_PathBuf, std_io_Error> = v1826 |> Ok
                                                                                                                    let _v1831 = v1839 
                                                                                                                    #endif
#else
                                                                                                                    let v1840 : Result<std_path_PathBuf, std_io_Error> = v1826 |> Ok
                                                                                                                    let _v1831 = v1840 
                                                                                                                    #endif
                                                                                                                    let v1841 : Result<std_path_PathBuf, std_io_Error> = _v1831 
                                                                                                                    v1841
                                                                                                            else
                                                                                                                let v1874 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v323} / path': {v288} / name: {v324}"
                                                                                                                let v1875 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1876 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v1877 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1874 v1876 
                                                                                                                let _v1875 = v1877 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1878 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v1879 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1874 v1878 
                                                                                                                let _v1875 = v1879 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1880 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v1881 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1874 v1880 
                                                                                                                let _v1875 = v1881 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1882 : std_io_Error = v1874 
                                                                                                                let _v1875 = v1882 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1883 : std_io_Error = v1874 
                                                                                                                let _v1875 = v1883 
                                                                                                                #endif
#else
                                                                                                                let v1884 : std_io_Error = v1874 
                                                                                                                let _v1875 = v1884 
                                                                                                                #endif
                                                                                                                let v1885 : std_io_Error = _v1875 
                                                                                                                let v1888 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v1889 : string = "Err($0)"
                                                                                                                let v1890 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1885 v1889 
                                                                                                                let _v1888 = v1890 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v1891 : string = "Err($0)"
                                                                                                                let v1892 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1885 v1891 
                                                                                                                let _v1888 = v1892 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v1893 : string = "Err($0)"
                                                                                                                let v1894 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1885 v1893 
                                                                                                                let _v1888 = v1894 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v1895 : Result<std_path_PathBuf, std_io_Error> = v1885 |> Error
                                                                                                                let _v1888 = v1895 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v1896 : Result<std_path_PathBuf, std_io_Error> = v1885 |> Error
                                                                                                                let _v1888 = v1896 
                                                                                                                #endif
#else
                                                                                                                let v1897 : Result<std_path_PathBuf, std_io_Error> = v1885 |> Error
                                                                                                                let _v1888 = v1897 
                                                                                                                #endif
                                                                                                                let v1898 : Result<std_path_PathBuf, std_io_Error> = _v1888 
                                                                                                                v1898
                                                                                                        | _ ->
                                                                                                            let v1902 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v323} / path': {v288} / name: {v324}"
                                                                                                            let v1903 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v1904 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v1905 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1902 v1904 
                                                                                                            let _v1903 = v1905 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v1906 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v1907 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1902 v1906 
                                                                                                            let _v1903 = v1907 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v1908 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v1909 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v1902 v1908 
                                                                                                            let _v1903 = v1909 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v1910 : std_io_Error = v1902 
                                                                                                            let _v1903 = v1910 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v1911 : std_io_Error = v1902 
                                                                                                            let _v1903 = v1911 
                                                                                                            #endif
#else
                                                                                                            let v1912 : std_io_Error = v1902 
                                                                                                            let _v1903 = v1912 
                                                                                                            #endif
                                                                                                            let v1913 : std_io_Error = _v1903 
                                                                                                            let v1916 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v1917 : string = "Err($0)"
                                                                                                            let v1918 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1913 v1917 
                                                                                                            let _v1916 = v1918 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v1919 : string = "Err($0)"
                                                                                                            let v1920 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1913 v1919 
                                                                                                            let _v1916 = v1920 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v1921 : string = "Err($0)"
                                                                                                            let v1922 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1913 v1921 
                                                                                                            let _v1916 = v1922 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v1923 : Result<std_path_PathBuf, std_io_Error> = v1913 |> Error
                                                                                                            let _v1916 = v1923 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v1924 : Result<std_path_PathBuf, std_io_Error> = v1913 |> Error
                                                                                                            let _v1916 = v1924 
                                                                                                            #endif
#else
                                                                                                            let v1925 : Result<std_path_PathBuf, std_io_Error> = v1913 |> Error
                                                                                                            let _v1916 = v1925 
                                                                                                            #endif
                                                                                                            let v1926 : Result<std_path_PathBuf, std_io_Error> = _v1916 
                                                                                                            v1926
                                                                                                    | US13_0(v309) -> (* Ok *)
                                                                                                        let v310 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v311 : string = "Ok($0)"
                                                                                                        let v312 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v309 v311 
                                                                                                        let _v310 = v312 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v313 : string = "Ok($0)"
                                                                                                        let v314 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v309 v313 
                                                                                                        let _v310 = v314 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v315 : string = "Ok($0)"
                                                                                                        let v316 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v309 v315 
                                                                                                        let _v310 = v316 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v317 : Result<std_path_PathBuf, std_io_Error> = v309 |> Ok
                                                                                                        let _v310 = v317 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v318 : Result<std_path_PathBuf, std_io_Error> = v309 |> Ok
                                                                                                        let _v310 = v318 
                                                                                                        #endif
#else
                                                                                                        let v319 : Result<std_path_PathBuf, std_io_Error> = v309 |> Ok
                                                                                                        let _v310 = v319 
                                                                                                        #endif
                                                                                                        let v320 : Result<std_path_PathBuf, std_io_Error> = _v310 
                                                                                                        v320
                                                                                                let v1932 : (std_io_Error -> string) = method76()
                                                                                                let v1933 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v1934 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v1935 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1931, v1932) v1934 
                                                                                                let _v1933 = v1935 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v1936 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v1937 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1931, v1932) v1936 
                                                                                                let _v1933 = v1937 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v1938 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v1939 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v1931, v1932) v1938 
                                                                                                let _v1933 = v1939 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v1940 : Result<std_path_PathBuf, string> = match v1931 with Ok x -> Ok x | Error x -> Error (v1932 x)
                                                                                                let _v1933 = v1940 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v1941 : Result<std_path_PathBuf, string> = match v1931 with Ok x -> Ok x | Error x -> Error (v1932 x)
                                                                                                let _v1933 = v1941 
                                                                                                #endif
#else
                                                                                                let v1942 : Result<std_path_PathBuf, string> = match v1931 with Ok x -> Ok x | Error x -> Error (v1932 x)
                                                                                                let _v1933 = v1942 
                                                                                                #endif
                                                                                                let v1943 : Result<std_path_PathBuf, string> = _v1933 
                                                                                                let v1946 : US13 = match v1943 with Ok x -> v30 x | Error x -> v31 x
                                                                                                match v1946 with
                                                                                                | US13_1(v2049) -> (* Error *)
                                                                                                    let v2050 : string = $"file_system.read_link / error': {v2049} / error: {v268} / name: {v269}"
                                                                                                    let v2051 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v2052 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v2053 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2050 v2052 
                                                                                                    let _v2051 = v2053 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v2054 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v2055 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2050 v2054 
                                                                                                    let _v2051 = v2055 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v2056 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v2057 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2050 v2056 
                                                                                                    let _v2051 = v2057 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v2058 : std_io_Error = v2050 
                                                                                                    let _v2051 = v2058 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v2059 : std_io_Error = v2050 
                                                                                                    let _v2051 = v2059 
                                                                                                    #endif
#else
                                                                                                    let v2060 : std_io_Error = v2050 
                                                                                                    let _v2051 = v2060 
                                                                                                    #endif
                                                                                                    let v2061 : std_io_Error = _v2051 
                                                                                                    let v2064 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v2065 : string = "Err($0)"
                                                                                                    let v2066 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2061 v2065 
                                                                                                    let _v2064 = v2066 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v2067 : string = "Err($0)"
                                                                                                    let v2068 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2061 v2067 
                                                                                                    let _v2064 = v2068 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v2069 : string = "Err($0)"
                                                                                                    let v2070 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2061 v2069 
                                                                                                    let _v2064 = v2070 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v2071 : Result<std_path_PathBuf, std_io_Error> = v2061 |> Error
                                                                                                    let _v2064 = v2071 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v2072 : Result<std_path_PathBuf, std_io_Error> = v2061 |> Error
                                                                                                    let _v2064 = v2072 
                                                                                                    #endif
#else
                                                                                                    let v2073 : Result<std_path_PathBuf, std_io_Error> = v2061 |> Error
                                                                                                    let _v2064 = v2073 
                                                                                                    #endif
                                                                                                    let v2074 : Result<std_path_PathBuf, std_io_Error> = _v2064 
                                                                                                    v2074
                                                                                                | US13_0(v1947) -> (* Ok *)
                                                                                                    let v1948 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v1949 : string = "$0.display()"
                                                                                                    let v1950 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1947 v1949 
                                                                                                    let _v1948 = v1950 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v1951 : string = "$0.display()"
                                                                                                    let v1952 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1947 v1951 
                                                                                                    let _v1948 = v1952 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v1953 : string = "$0.display()"
                                                                                                    let v1954 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v1947 v1953 
                                                                                                    let _v1948 = v1954 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v1955 : std_path_Display = v1947 |> unbox<std_path_Display>
                                                                                                    let _v1948 = v1955 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v1958 : std_path_Display = v1947 |> unbox<std_path_Display>
                                                                                                    let _v1948 = v1958 
                                                                                                    #endif
#else
                                                                                                    let v1961 : std_path_Display = v1947 |> unbox<std_path_Display>
                                                                                                    let _v1948 = v1961 
                                                                                                    #endif
                                                                                                    let v1964 : std_path_Display = _v1948 
                                                                                                    let v1969 : string = v1964 |> string 
                                                                                                    let v1972 : string = method56(v1969, v269)
                                                                                                    let v1973 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v1974 : string = "&*$0"
                                                                                                    let v1975 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1972 v1974 
                                                                                                    let _v1973 = v1975 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v1976 : string = "&*$0"
                                                                                                    let v1977 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1972 v1976 
                                                                                                    let _v1973 = v1977 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v1978 : string = "&*$0"
                                                                                                    let v1979 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v1972 v1978 
                                                                                                    let _v1973 = v1979 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v1980 : Ref<Str> = v1972 |> unbox<Ref<Str>>
                                                                                                    let _v1973 = v1980 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v1983 : Ref<Str> = v1972 |> unbox<Ref<Str>>
                                                                                                    let _v1973 = v1983 
                                                                                                    #endif
#else
                                                                                                    let v1986 : Ref<Str> = v1972 |> unbox<Ref<Str>>
                                                                                                    let _v1973 = v1986 
                                                                                                    #endif
                                                                                                    let v1989 : Ref<Str> = _v1973 
                                                                                                    let v1994 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v1995 : string = "String::from($0)"
                                                                                                    let v1996 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1989 v1995 
                                                                                                    let _v1994 = v1996 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v1997 : string = "String::from($0)"
                                                                                                    let v1998 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1989 v1997 
                                                                                                    let _v1994 = v1998 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v1999 : string = "String::from($0)"
                                                                                                    let v2000 : std_string_String = Fable.Core.RustInterop.emitRustExpr v1989 v1999 
                                                                                                    let _v1994 = v2000 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v2001 : std_string_String = v1989 |> unbox<std_string_String>
                                                                                                    let _v1994 = v2001 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v2004 : std_string_String = v1989 |> unbox<std_string_String>
                                                                                                    let _v1994 = v2004 
                                                                                                    #endif
#else
                                                                                                    let v2007 : std_string_String = v1989 |> unbox<std_string_String>
                                                                                                    let _v1994 = v2007 
                                                                                                    #endif
                                                                                                    let v2010 : std_string_String = _v1994 
                                                                                                    let v2015 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v2016 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v2017 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2010 v2016 
                                                                                                    let _v2015 = v2017 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v2018 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v2019 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2010 v2018 
                                                                                                    let _v2015 = v2019 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v2020 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v2021 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2010 v2020 
                                                                                                    let _v2015 = v2021 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v2022 : std_path_PathBuf = v2010 |> std_path_PathBuf 
                                                                                                    let _v2015 = v2022 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v2025 : std_path_PathBuf = v2010 |> std_path_PathBuf 
                                                                                                    let _v2015 = v2025 
                                                                                                    #endif
#else
                                                                                                    let v2028 : std_path_PathBuf = v2010 |> std_path_PathBuf 
                                                                                                    let _v2015 = v2028 
                                                                                                    #endif
                                                                                                    let v2031 : std_path_PathBuf = _v2015 
                                                                                                    let v2036 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v2037 : string = "Ok($0)"
                                                                                                    let v2038 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2031 v2037 
                                                                                                    let _v2036 = v2038 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v2039 : string = "Ok($0)"
                                                                                                    let v2040 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2031 v2039 
                                                                                                    let _v2036 = v2040 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v2041 : string = "Ok($0)"
                                                                                                    let v2042 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2031 v2041 
                                                                                                    let _v2036 = v2042 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v2043 : Result<std_path_PathBuf, std_io_Error> = v2031 |> Ok
                                                                                                    let _v2036 = v2043 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v2044 : Result<std_path_PathBuf, std_io_Error> = v2031 |> Ok
                                                                                                    let _v2036 = v2044 
                                                                                                    #endif
#else
                                                                                                    let v2045 : Result<std_path_PathBuf, std_io_Error> = v2031 |> Ok
                                                                                                    let _v2036 = v2045 
                                                                                                    #endif
                                                                                                    let v2046 : Result<std_path_PathBuf, std_io_Error> = _v2036 
                                                                                                    v2046
                                                                                            else
                                                                                                let v2079 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v268} / path': {v233} / name: {v269}"
                                                                                                let v2080 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v2081 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v2082 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2079 v2081 
                                                                                                let _v2080 = v2082 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v2083 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v2084 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2079 v2083 
                                                                                                let _v2080 = v2084 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v2085 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v2086 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2079 v2085 
                                                                                                let _v2080 = v2086 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v2087 : std_io_Error = v2079 
                                                                                                let _v2080 = v2087 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v2088 : std_io_Error = v2079 
                                                                                                let _v2080 = v2088 
                                                                                                #endif
#else
                                                                                                let v2089 : std_io_Error = v2079 
                                                                                                let _v2080 = v2089 
                                                                                                #endif
                                                                                                let v2090 : std_io_Error = _v2080 
                                                                                                let v2093 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v2094 : string = "Err($0)"
                                                                                                let v2095 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2090 v2094 
                                                                                                let _v2093 = v2095 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v2096 : string = "Err($0)"
                                                                                                let v2097 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2090 v2096 
                                                                                                let _v2093 = v2097 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v2098 : string = "Err($0)"
                                                                                                let v2099 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2090 v2098 
                                                                                                let _v2093 = v2099 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v2100 : Result<std_path_PathBuf, std_io_Error> = v2090 |> Error
                                                                                                let _v2093 = v2100 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v2101 : Result<std_path_PathBuf, std_io_Error> = v2090 |> Error
                                                                                                let _v2093 = v2101 
                                                                                                #endif
#else
                                                                                                let v2102 : Result<std_path_PathBuf, std_io_Error> = v2090 |> Error
                                                                                                let _v2093 = v2102 
                                                                                                #endif
                                                                                                let v2103 : Result<std_path_PathBuf, std_io_Error> = _v2093 
                                                                                                v2103
                                                                                        | _ ->
                                                                                            let v2107 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v268} / path': {v233} / name: {v269}"
                                                                                            let v2108 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v2109 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v2110 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2107 v2109 
                                                                                            let _v2108 = v2110 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v2111 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v2112 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2107 v2111 
                                                                                            let _v2108 = v2112 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v2113 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v2114 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2107 v2113 
                                                                                            let _v2108 = v2114 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v2115 : std_io_Error = v2107 
                                                                                            let _v2108 = v2115 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v2116 : std_io_Error = v2107 
                                                                                            let _v2108 = v2116 
                                                                                            #endif
#else
                                                                                            let v2117 : std_io_Error = v2107 
                                                                                            let _v2108 = v2117 
                                                                                            #endif
                                                                                            let v2118 : std_io_Error = _v2108 
                                                                                            let v2121 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v2122 : string = "Err($0)"
                                                                                            let v2123 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2118 v2122 
                                                                                            let _v2121 = v2123 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v2124 : string = "Err($0)"
                                                                                            let v2125 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2118 v2124 
                                                                                            let _v2121 = v2125 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v2126 : string = "Err($0)"
                                                                                            let v2127 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2118 v2126 
                                                                                            let _v2121 = v2127 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v2128 : Result<std_path_PathBuf, std_io_Error> = v2118 |> Error
                                                                                            let _v2121 = v2128 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v2129 : Result<std_path_PathBuf, std_io_Error> = v2118 |> Error
                                                                                            let _v2121 = v2129 
                                                                                            #endif
#else
                                                                                            let v2130 : Result<std_path_PathBuf, std_io_Error> = v2118 |> Error
                                                                                            let _v2121 = v2130 
                                                                                            #endif
                                                                                            let v2131 : Result<std_path_PathBuf, std_io_Error> = _v2121 
                                                                                            v2131
                                                                                    | US13_0(v254) -> (* Ok *)
                                                                                        let v255 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v256 : string = "Ok($0)"
                                                                                        let v257 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v254 v256 
                                                                                        let _v255 = v257 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v258 : string = "Ok($0)"
                                                                                        let v259 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v254 v258 
                                                                                        let _v255 = v259 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v260 : string = "Ok($0)"
                                                                                        let v261 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v254 v260 
                                                                                        let _v255 = v261 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v262 : Result<std_path_PathBuf, std_io_Error> = v254 |> Ok
                                                                                        let _v255 = v262 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v263 : Result<std_path_PathBuf, std_io_Error> = v254 |> Ok
                                                                                        let _v255 = v263 
                                                                                        #endif
#else
                                                                                        let v264 : Result<std_path_PathBuf, std_io_Error> = v254 |> Ok
                                                                                        let _v255 = v264 
                                                                                        #endif
                                                                                        let v265 : Result<std_path_PathBuf, std_io_Error> = _v255 
                                                                                        v265
                                                                                let v2137 : (std_io_Error -> string) = method76()
                                                                                let v2138 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2139 : string = "$0.map_err(|x| $1(x))"
                                                                                let v2140 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2136, v2137) v2139 
                                                                                let _v2138 = v2140 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2141 : string = "$0.map_err(|x| $1(x))"
                                                                                let v2142 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2136, v2137) v2141 
                                                                                let _v2138 = v2142 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2143 : string = "$0.map_err(|x| $1(x))"
                                                                                let v2144 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2136, v2137) v2143 
                                                                                let _v2138 = v2144 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2145 : Result<std_path_PathBuf, string> = match v2136 with Ok x -> Ok x | Error x -> Error (v2137 x)
                                                                                let _v2138 = v2145 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2146 : Result<std_path_PathBuf, string> = match v2136 with Ok x -> Ok x | Error x -> Error (v2137 x)
                                                                                let _v2138 = v2146 
                                                                                #endif
#else
                                                                                let v2147 : Result<std_path_PathBuf, string> = match v2136 with Ok x -> Ok x | Error x -> Error (v2137 x)
                                                                                let _v2138 = v2147 
                                                                                #endif
                                                                                let v2148 : Result<std_path_PathBuf, string> = _v2138 
                                                                                let v2151 : US13 = match v2148 with Ok x -> v30 x | Error x -> v31 x
                                                                                match v2151 with
                                                                                | US13_1(v2254) -> (* Error *)
                                                                                    let v2255 : string = $"file_system.read_link / error': {v2254} / error: {v213} / name: {v214}"
                                                                                    let v2256 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v2257 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v2258 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2255 v2257 
                                                                                    let _v2256 = v2258 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v2259 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v2260 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2255 v2259 
                                                                                    let _v2256 = v2260 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v2261 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v2262 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2255 v2261 
                                                                                    let _v2256 = v2262 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v2263 : std_io_Error = v2255 
                                                                                    let _v2256 = v2263 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v2264 : std_io_Error = v2255 
                                                                                    let _v2256 = v2264 
                                                                                    #endif
#else
                                                                                    let v2265 : std_io_Error = v2255 
                                                                                    let _v2256 = v2265 
                                                                                    #endif
                                                                                    let v2266 : std_io_Error = _v2256 
                                                                                    let v2269 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v2270 : string = "Err($0)"
                                                                                    let v2271 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2266 v2270 
                                                                                    let _v2269 = v2271 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v2272 : string = "Err($0)"
                                                                                    let v2273 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2266 v2272 
                                                                                    let _v2269 = v2273 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v2274 : string = "Err($0)"
                                                                                    let v2275 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2266 v2274 
                                                                                    let _v2269 = v2275 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v2276 : Result<std_path_PathBuf, std_io_Error> = v2266 |> Error
                                                                                    let _v2269 = v2276 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v2277 : Result<std_path_PathBuf, std_io_Error> = v2266 |> Error
                                                                                    let _v2269 = v2277 
                                                                                    #endif
#else
                                                                                    let v2278 : Result<std_path_PathBuf, std_io_Error> = v2266 |> Error
                                                                                    let _v2269 = v2278 
                                                                                    #endif
                                                                                    let v2279 : Result<std_path_PathBuf, std_io_Error> = _v2269 
                                                                                    v2279
                                                                                | US13_0(v2152) -> (* Ok *)
                                                                                    let v2153 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v2154 : string = "$0.display()"
                                                                                    let v2155 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2152 v2154 
                                                                                    let _v2153 = v2155 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v2156 : string = "$0.display()"
                                                                                    let v2157 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2152 v2156 
                                                                                    let _v2153 = v2157 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v2158 : string = "$0.display()"
                                                                                    let v2159 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2152 v2158 
                                                                                    let _v2153 = v2159 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v2160 : std_path_Display = v2152 |> unbox<std_path_Display>
                                                                                    let _v2153 = v2160 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v2163 : std_path_Display = v2152 |> unbox<std_path_Display>
                                                                                    let _v2153 = v2163 
                                                                                    #endif
#else
                                                                                    let v2166 : std_path_Display = v2152 |> unbox<std_path_Display>
                                                                                    let _v2153 = v2166 
                                                                                    #endif
                                                                                    let v2169 : std_path_Display = _v2153 
                                                                                    let v2174 : string = v2169 |> string 
                                                                                    let v2177 : string = method56(v2174, v214)
                                                                                    let v2178 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v2179 : string = "&*$0"
                                                                                    let v2180 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2177 v2179 
                                                                                    let _v2178 = v2180 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v2181 : string = "&*$0"
                                                                                    let v2182 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2177 v2181 
                                                                                    let _v2178 = v2182 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v2183 : string = "&*$0"
                                                                                    let v2184 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2177 v2183 
                                                                                    let _v2178 = v2184 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v2185 : Ref<Str> = v2177 |> unbox<Ref<Str>>
                                                                                    let _v2178 = v2185 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v2188 : Ref<Str> = v2177 |> unbox<Ref<Str>>
                                                                                    let _v2178 = v2188 
                                                                                    #endif
#else
                                                                                    let v2191 : Ref<Str> = v2177 |> unbox<Ref<Str>>
                                                                                    let _v2178 = v2191 
                                                                                    #endif
                                                                                    let v2194 : Ref<Str> = _v2178 
                                                                                    let v2199 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v2200 : string = "String::from($0)"
                                                                                    let v2201 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2194 v2200 
                                                                                    let _v2199 = v2201 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v2202 : string = "String::from($0)"
                                                                                    let v2203 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2194 v2202 
                                                                                    let _v2199 = v2203 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v2204 : string = "String::from($0)"
                                                                                    let v2205 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2194 v2204 
                                                                                    let _v2199 = v2205 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v2206 : std_string_String = v2194 |> unbox<std_string_String>
                                                                                    let _v2199 = v2206 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v2209 : std_string_String = v2194 |> unbox<std_string_String>
                                                                                    let _v2199 = v2209 
                                                                                    #endif
#else
                                                                                    let v2212 : std_string_String = v2194 |> unbox<std_string_String>
                                                                                    let _v2199 = v2212 
                                                                                    #endif
                                                                                    let v2215 : std_string_String = _v2199 
                                                                                    let v2220 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v2221 : string = "std::path::PathBuf::from($0)"
                                                                                    let v2222 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2215 v2221 
                                                                                    let _v2220 = v2222 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v2223 : string = "std::path::PathBuf::from($0)"
                                                                                    let v2224 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2215 v2223 
                                                                                    let _v2220 = v2224 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v2225 : string = "std::path::PathBuf::from($0)"
                                                                                    let v2226 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2215 v2225 
                                                                                    let _v2220 = v2226 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v2227 : std_path_PathBuf = v2215 |> std_path_PathBuf 
                                                                                    let _v2220 = v2227 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v2230 : std_path_PathBuf = v2215 |> std_path_PathBuf 
                                                                                    let _v2220 = v2230 
                                                                                    #endif
#else
                                                                                    let v2233 : std_path_PathBuf = v2215 |> std_path_PathBuf 
                                                                                    let _v2220 = v2233 
                                                                                    #endif
                                                                                    let v2236 : std_path_PathBuf = _v2220 
                                                                                    let v2241 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v2242 : string = "Ok($0)"
                                                                                    let v2243 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2236 v2242 
                                                                                    let _v2241 = v2243 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v2244 : string = "Ok($0)"
                                                                                    let v2245 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2236 v2244 
                                                                                    let _v2241 = v2245 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v2246 : string = "Ok($0)"
                                                                                    let v2247 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2236 v2246 
                                                                                    let _v2241 = v2247 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v2248 : Result<std_path_PathBuf, std_io_Error> = v2236 |> Ok
                                                                                    let _v2241 = v2248 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v2249 : Result<std_path_PathBuf, std_io_Error> = v2236 |> Ok
                                                                                    let _v2241 = v2249 
                                                                                    #endif
#else
                                                                                    let v2250 : Result<std_path_PathBuf, std_io_Error> = v2236 |> Ok
                                                                                    let _v2241 = v2250 
                                                                                    #endif
                                                                                    let v2251 : Result<std_path_PathBuf, std_io_Error> = _v2241 
                                                                                    v2251
                                                                            else
                                                                                let v2284 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v213} / path': {v178} / name: {v214}"
                                                                                let v2285 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2286 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v2287 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2284 v2286 
                                                                                let _v2285 = v2287 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2288 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v2289 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2284 v2288 
                                                                                let _v2285 = v2289 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2290 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v2291 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2284 v2290 
                                                                                let _v2285 = v2291 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2292 : std_io_Error = v2284 
                                                                                let _v2285 = v2292 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2293 : std_io_Error = v2284 
                                                                                let _v2285 = v2293 
                                                                                #endif
#else
                                                                                let v2294 : std_io_Error = v2284 
                                                                                let _v2285 = v2294 
                                                                                #endif
                                                                                let v2295 : std_io_Error = _v2285 
                                                                                let v2298 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v2299 : string = "Err($0)"
                                                                                let v2300 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2295 v2299 
                                                                                let _v2298 = v2300 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v2301 : string = "Err($0)"
                                                                                let v2302 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2295 v2301 
                                                                                let _v2298 = v2302 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v2303 : string = "Err($0)"
                                                                                let v2304 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2295 v2303 
                                                                                let _v2298 = v2304 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v2305 : Result<std_path_PathBuf, std_io_Error> = v2295 |> Error
                                                                                let _v2298 = v2305 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v2306 : Result<std_path_PathBuf, std_io_Error> = v2295 |> Error
                                                                                let _v2298 = v2306 
                                                                                #endif
#else
                                                                                let v2307 : Result<std_path_PathBuf, std_io_Error> = v2295 |> Error
                                                                                let _v2298 = v2307 
                                                                                #endif
                                                                                let v2308 : Result<std_path_PathBuf, std_io_Error> = _v2298 
                                                                                v2308
                                                                        | _ ->
                                                                            let v2312 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v213} / path': {v178} / name: {v214}"
                                                                            let v2313 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v2314 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v2315 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2312 v2314 
                                                                            let _v2313 = v2315 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v2316 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v2317 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2312 v2316 
                                                                            let _v2313 = v2317 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v2318 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v2319 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2312 v2318 
                                                                            let _v2313 = v2319 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v2320 : std_io_Error = v2312 
                                                                            let _v2313 = v2320 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v2321 : std_io_Error = v2312 
                                                                            let _v2313 = v2321 
                                                                            #endif
#else
                                                                            let v2322 : std_io_Error = v2312 
                                                                            let _v2313 = v2322 
                                                                            #endif
                                                                            let v2323 : std_io_Error = _v2313 
                                                                            let v2326 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v2327 : string = "Err($0)"
                                                                            let v2328 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2323 v2327 
                                                                            let _v2326 = v2328 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v2329 : string = "Err($0)"
                                                                            let v2330 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2323 v2329 
                                                                            let _v2326 = v2330 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v2331 : string = "Err($0)"
                                                                            let v2332 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2323 v2331 
                                                                            let _v2326 = v2332 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v2333 : Result<std_path_PathBuf, std_io_Error> = v2323 |> Error
                                                                            let _v2326 = v2333 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v2334 : Result<std_path_PathBuf, std_io_Error> = v2323 |> Error
                                                                            let _v2326 = v2334 
                                                                            #endif
#else
                                                                            let v2335 : Result<std_path_PathBuf, std_io_Error> = v2323 |> Error
                                                                            let _v2326 = v2335 
                                                                            #endif
                                                                            let v2336 : Result<std_path_PathBuf, std_io_Error> = _v2326 
                                                                            v2336
                                                                    | US13_0(v199) -> (* Ok *)
                                                                        let v200 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v201 : string = "Ok($0)"
                                                                        let v202 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v199 v201 
                                                                        let _v200 = v202 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v203 : string = "Ok($0)"
                                                                        let v204 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v199 v203 
                                                                        let _v200 = v204 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v205 : string = "Ok($0)"
                                                                        let v206 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v199 v205 
                                                                        let _v200 = v206 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v207 : Result<std_path_PathBuf, std_io_Error> = v199 |> Ok
                                                                        let _v200 = v207 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v208 : Result<std_path_PathBuf, std_io_Error> = v199 |> Ok
                                                                        let _v200 = v208 
                                                                        #endif
#else
                                                                        let v209 : Result<std_path_PathBuf, std_io_Error> = v199 |> Ok
                                                                        let _v200 = v209 
                                                                        #endif
                                                                        let v210 : Result<std_path_PathBuf, std_io_Error> = _v200 
                                                                        v210
                                                                let v2342 : (std_io_Error -> string) = method76()
                                                                let v2343 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2344 : string = "$0.map_err(|x| $1(x))"
                                                                let v2345 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2341, v2342) v2344 
                                                                let _v2343 = v2345 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2346 : string = "$0.map_err(|x| $1(x))"
                                                                let v2347 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2341, v2342) v2346 
                                                                let _v2343 = v2347 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2348 : string = "$0.map_err(|x| $1(x))"
                                                                let v2349 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2341, v2342) v2348 
                                                                let _v2343 = v2349 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2350 : Result<std_path_PathBuf, string> = match v2341 with Ok x -> Ok x | Error x -> Error (v2342 x)
                                                                let _v2343 = v2350 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2351 : Result<std_path_PathBuf, string> = match v2341 with Ok x -> Ok x | Error x -> Error (v2342 x)
                                                                let _v2343 = v2351 
                                                                #endif
#else
                                                                let v2352 : Result<std_path_PathBuf, string> = match v2341 with Ok x -> Ok x | Error x -> Error (v2342 x)
                                                                let _v2343 = v2352 
                                                                #endif
                                                                let v2353 : Result<std_path_PathBuf, string> = _v2343 
                                                                let v2356 : US13 = match v2353 with Ok x -> v30 x | Error x -> v31 x
                                                                match v2356 with
                                                                | US13_1(v2459) -> (* Error *)
                                                                    let v2460 : string = $"file_system.read_link / error': {v2459} / error: {v158} / name: {v159}"
                                                                    let v2461 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v2462 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v2463 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2460 v2462 
                                                                    let _v2461 = v2463 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v2464 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v2465 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2460 v2464 
                                                                    let _v2461 = v2465 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v2466 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v2467 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2460 v2466 
                                                                    let _v2461 = v2467 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v2468 : std_io_Error = v2460 
                                                                    let _v2461 = v2468 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v2469 : std_io_Error = v2460 
                                                                    let _v2461 = v2469 
                                                                    #endif
#else
                                                                    let v2470 : std_io_Error = v2460 
                                                                    let _v2461 = v2470 
                                                                    #endif
                                                                    let v2471 : std_io_Error = _v2461 
                                                                    let v2474 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v2475 : string = "Err($0)"
                                                                    let v2476 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2471 v2475 
                                                                    let _v2474 = v2476 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v2477 : string = "Err($0)"
                                                                    let v2478 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2471 v2477 
                                                                    let _v2474 = v2478 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v2479 : string = "Err($0)"
                                                                    let v2480 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2471 v2479 
                                                                    let _v2474 = v2480 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v2481 : Result<std_path_PathBuf, std_io_Error> = v2471 |> Error
                                                                    let _v2474 = v2481 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v2482 : Result<std_path_PathBuf, std_io_Error> = v2471 |> Error
                                                                    let _v2474 = v2482 
                                                                    #endif
#else
                                                                    let v2483 : Result<std_path_PathBuf, std_io_Error> = v2471 |> Error
                                                                    let _v2474 = v2483 
                                                                    #endif
                                                                    let v2484 : Result<std_path_PathBuf, std_io_Error> = _v2474 
                                                                    v2484
                                                                | US13_0(v2357) -> (* Ok *)
                                                                    let v2358 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v2359 : string = "$0.display()"
                                                                    let v2360 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2357 v2359 
                                                                    let _v2358 = v2360 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v2361 : string = "$0.display()"
                                                                    let v2362 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2357 v2361 
                                                                    let _v2358 = v2362 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v2363 : string = "$0.display()"
                                                                    let v2364 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2357 v2363 
                                                                    let _v2358 = v2364 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v2365 : std_path_Display = v2357 |> unbox<std_path_Display>
                                                                    let _v2358 = v2365 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v2368 : std_path_Display = v2357 |> unbox<std_path_Display>
                                                                    let _v2358 = v2368 
                                                                    #endif
#else
                                                                    let v2371 : std_path_Display = v2357 |> unbox<std_path_Display>
                                                                    let _v2358 = v2371 
                                                                    #endif
                                                                    let v2374 : std_path_Display = _v2358 
                                                                    let v2379 : string = v2374 |> string 
                                                                    let v2382 : string = method56(v2379, v159)
                                                                    let v2383 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v2384 : string = "&*$0"
                                                                    let v2385 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2382 v2384 
                                                                    let _v2383 = v2385 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v2386 : string = "&*$0"
                                                                    let v2387 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2382 v2386 
                                                                    let _v2383 = v2387 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v2388 : string = "&*$0"
                                                                    let v2389 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2382 v2388 
                                                                    let _v2383 = v2389 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v2390 : Ref<Str> = v2382 |> unbox<Ref<Str>>
                                                                    let _v2383 = v2390 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v2393 : Ref<Str> = v2382 |> unbox<Ref<Str>>
                                                                    let _v2383 = v2393 
                                                                    #endif
#else
                                                                    let v2396 : Ref<Str> = v2382 |> unbox<Ref<Str>>
                                                                    let _v2383 = v2396 
                                                                    #endif
                                                                    let v2399 : Ref<Str> = _v2383 
                                                                    let v2404 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v2405 : string = "String::from($0)"
                                                                    let v2406 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2399 v2405 
                                                                    let _v2404 = v2406 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v2407 : string = "String::from($0)"
                                                                    let v2408 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2399 v2407 
                                                                    let _v2404 = v2408 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v2409 : string = "String::from($0)"
                                                                    let v2410 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2399 v2409 
                                                                    let _v2404 = v2410 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v2411 : std_string_String = v2399 |> unbox<std_string_String>
                                                                    let _v2404 = v2411 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v2414 : std_string_String = v2399 |> unbox<std_string_String>
                                                                    let _v2404 = v2414 
                                                                    #endif
#else
                                                                    let v2417 : std_string_String = v2399 |> unbox<std_string_String>
                                                                    let _v2404 = v2417 
                                                                    #endif
                                                                    let v2420 : std_string_String = _v2404 
                                                                    let v2425 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v2426 : string = "std::path::PathBuf::from($0)"
                                                                    let v2427 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2420 v2426 
                                                                    let _v2425 = v2427 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v2428 : string = "std::path::PathBuf::from($0)"
                                                                    let v2429 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2420 v2428 
                                                                    let _v2425 = v2429 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v2430 : string = "std::path::PathBuf::from($0)"
                                                                    let v2431 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2420 v2430 
                                                                    let _v2425 = v2431 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v2432 : std_path_PathBuf = v2420 |> std_path_PathBuf 
                                                                    let _v2425 = v2432 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v2435 : std_path_PathBuf = v2420 |> std_path_PathBuf 
                                                                    let _v2425 = v2435 
                                                                    #endif
#else
                                                                    let v2438 : std_path_PathBuf = v2420 |> std_path_PathBuf 
                                                                    let _v2425 = v2438 
                                                                    #endif
                                                                    let v2441 : std_path_PathBuf = _v2425 
                                                                    let v2446 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v2447 : string = "Ok($0)"
                                                                    let v2448 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2441 v2447 
                                                                    let _v2446 = v2448 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v2449 : string = "Ok($0)"
                                                                    let v2450 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2441 v2449 
                                                                    let _v2446 = v2450 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v2451 : string = "Ok($0)"
                                                                    let v2452 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2441 v2451 
                                                                    let _v2446 = v2452 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v2453 : Result<std_path_PathBuf, std_io_Error> = v2441 |> Ok
                                                                    let _v2446 = v2453 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v2454 : Result<std_path_PathBuf, std_io_Error> = v2441 |> Ok
                                                                    let _v2446 = v2454 
                                                                    #endif
#else
                                                                    let v2455 : Result<std_path_PathBuf, std_io_Error> = v2441 |> Ok
                                                                    let _v2446 = v2455 
                                                                    #endif
                                                                    let v2456 : Result<std_path_PathBuf, std_io_Error> = _v2446 
                                                                    v2456
                                                            else
                                                                let v2489 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v158} / path': {v123} / name: {v159}"
                                                                let v2490 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2491 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v2492 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2489 v2491 
                                                                let _v2490 = v2492 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2493 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v2494 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2489 v2493 
                                                                let _v2490 = v2494 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2495 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v2496 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2489 v2495 
                                                                let _v2490 = v2496 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2497 : std_io_Error = v2489 
                                                                let _v2490 = v2497 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2498 : std_io_Error = v2489 
                                                                let _v2490 = v2498 
                                                                #endif
#else
                                                                let v2499 : std_io_Error = v2489 
                                                                let _v2490 = v2499 
                                                                #endif
                                                                let v2500 : std_io_Error = _v2490 
                                                                let v2503 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v2504 : string = "Err($0)"
                                                                let v2505 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2500 v2504 
                                                                let _v2503 = v2505 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v2506 : string = "Err($0)"
                                                                let v2507 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2500 v2506 
                                                                let _v2503 = v2507 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v2508 : string = "Err($0)"
                                                                let v2509 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2500 v2508 
                                                                let _v2503 = v2509 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v2510 : Result<std_path_PathBuf, std_io_Error> = v2500 |> Error
                                                                let _v2503 = v2510 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v2511 : Result<std_path_PathBuf, std_io_Error> = v2500 |> Error
                                                                let _v2503 = v2511 
                                                                #endif
#else
                                                                let v2512 : Result<std_path_PathBuf, std_io_Error> = v2500 |> Error
                                                                let _v2503 = v2512 
                                                                #endif
                                                                let v2513 : Result<std_path_PathBuf, std_io_Error> = _v2503 
                                                                v2513
                                                        | _ ->
                                                            let v2517 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v158} / path': {v123} / name: {v159}"
                                                            let v2518 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v2519 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v2520 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2517 v2519 
                                                            let _v2518 = v2520 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v2521 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v2522 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2517 v2521 
                                                            let _v2518 = v2522 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v2523 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v2524 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2517 v2523 
                                                            let _v2518 = v2524 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v2525 : std_io_Error = v2517 
                                                            let _v2518 = v2525 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v2526 : std_io_Error = v2517 
                                                            let _v2518 = v2526 
                                                            #endif
#else
                                                            let v2527 : std_io_Error = v2517 
                                                            let _v2518 = v2527 
                                                            #endif
                                                            let v2528 : std_io_Error = _v2518 
                                                            let v2531 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v2532 : string = "Err($0)"
                                                            let v2533 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2528 v2532 
                                                            let _v2531 = v2533 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v2534 : string = "Err($0)"
                                                            let v2535 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2528 v2534 
                                                            let _v2531 = v2535 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v2536 : string = "Err($0)"
                                                            let v2537 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2528 v2536 
                                                            let _v2531 = v2537 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v2538 : Result<std_path_PathBuf, std_io_Error> = v2528 |> Error
                                                            let _v2531 = v2538 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v2539 : Result<std_path_PathBuf, std_io_Error> = v2528 |> Error
                                                            let _v2531 = v2539 
                                                            #endif
#else
                                                            let v2540 : Result<std_path_PathBuf, std_io_Error> = v2528 |> Error
                                                            let _v2531 = v2540 
                                                            #endif
                                                            let v2541 : Result<std_path_PathBuf, std_io_Error> = _v2531 
                                                            v2541
                                                    | US13_0(v144) -> (* Ok *)
                                                        let v145 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v146 : string = "Ok($0)"
                                                        let v147 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v144 v146 
                                                        let _v145 = v147 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v148 : string = "Ok($0)"
                                                        let v149 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v144 v148 
                                                        let _v145 = v149 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v150 : string = "Ok($0)"
                                                        let v151 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v144 v150 
                                                        let _v145 = v151 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v152 : Result<std_path_PathBuf, std_io_Error> = v144 |> Ok
                                                        let _v145 = v152 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v153 : Result<std_path_PathBuf, std_io_Error> = v144 |> Ok
                                                        let _v145 = v153 
                                                        #endif
#else
                                                        let v154 : Result<std_path_PathBuf, std_io_Error> = v144 |> Ok
                                                        let _v145 = v154 
                                                        #endif
                                                        let v155 : Result<std_path_PathBuf, std_io_Error> = _v145 
                                                        v155
                                                let v2547 : (std_io_Error -> string) = method76()
                                                let v2548 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2549 : string = "$0.map_err(|x| $1(x))"
                                                let v2550 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2546, v2547) v2549 
                                                let _v2548 = v2550 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2551 : string = "$0.map_err(|x| $1(x))"
                                                let v2552 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2546, v2547) v2551 
                                                let _v2548 = v2552 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2553 : string = "$0.map_err(|x| $1(x))"
                                                let v2554 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2546, v2547) v2553 
                                                let _v2548 = v2554 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2555 : Result<std_path_PathBuf, string> = match v2546 with Ok x -> Ok x | Error x -> Error (v2547 x)
                                                let _v2548 = v2555 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2556 : Result<std_path_PathBuf, string> = match v2546 with Ok x -> Ok x | Error x -> Error (v2547 x)
                                                let _v2548 = v2556 
                                                #endif
#else
                                                let v2557 : Result<std_path_PathBuf, string> = match v2546 with Ok x -> Ok x | Error x -> Error (v2547 x)
                                                let _v2548 = v2557 
                                                #endif
                                                let v2558 : Result<std_path_PathBuf, string> = _v2548 
                                                let v2561 : US13 = match v2558 with Ok x -> v30 x | Error x -> v31 x
                                                match v2561 with
                                                | US13_1(v2664) -> (* Error *)
                                                    let v2665 : string = $"file_system.read_link / error': {v2664} / error: {v103} / name: {v104}"
                                                    let v2666 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v2667 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v2668 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2665 v2667 
                                                    let _v2666 = v2668 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v2669 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v2670 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2665 v2669 
                                                    let _v2666 = v2670 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v2671 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v2672 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2665 v2671 
                                                    let _v2666 = v2672 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v2673 : std_io_Error = v2665 
                                                    let _v2666 = v2673 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v2674 : std_io_Error = v2665 
                                                    let _v2666 = v2674 
                                                    #endif
#else
                                                    let v2675 : std_io_Error = v2665 
                                                    let _v2666 = v2675 
                                                    #endif
                                                    let v2676 : std_io_Error = _v2666 
                                                    let v2679 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v2680 : string = "Err($0)"
                                                    let v2681 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2676 v2680 
                                                    let _v2679 = v2681 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v2682 : string = "Err($0)"
                                                    let v2683 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2676 v2682 
                                                    let _v2679 = v2683 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v2684 : string = "Err($0)"
                                                    let v2685 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2676 v2684 
                                                    let _v2679 = v2685 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v2686 : Result<std_path_PathBuf, std_io_Error> = v2676 |> Error
                                                    let _v2679 = v2686 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v2687 : Result<std_path_PathBuf, std_io_Error> = v2676 |> Error
                                                    let _v2679 = v2687 
                                                    #endif
#else
                                                    let v2688 : Result<std_path_PathBuf, std_io_Error> = v2676 |> Error
                                                    let _v2679 = v2688 
                                                    #endif
                                                    let v2689 : Result<std_path_PathBuf, std_io_Error> = _v2679 
                                                    v2689
                                                | US13_0(v2562) -> (* Ok *)
                                                    let v2563 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v2564 : string = "$0.display()"
                                                    let v2565 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2562 v2564 
                                                    let _v2563 = v2565 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v2566 : string = "$0.display()"
                                                    let v2567 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2562 v2566 
                                                    let _v2563 = v2567 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v2568 : string = "$0.display()"
                                                    let v2569 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2562 v2568 
                                                    let _v2563 = v2569 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v2570 : std_path_Display = v2562 |> unbox<std_path_Display>
                                                    let _v2563 = v2570 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v2573 : std_path_Display = v2562 |> unbox<std_path_Display>
                                                    let _v2563 = v2573 
                                                    #endif
#else
                                                    let v2576 : std_path_Display = v2562 |> unbox<std_path_Display>
                                                    let _v2563 = v2576 
                                                    #endif
                                                    let v2579 : std_path_Display = _v2563 
                                                    let v2584 : string = v2579 |> string 
                                                    let v2587 : string = method56(v2584, v104)
                                                    let v2588 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v2589 : string = "&*$0"
                                                    let v2590 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2587 v2589 
                                                    let _v2588 = v2590 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v2591 : string = "&*$0"
                                                    let v2592 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2587 v2591 
                                                    let _v2588 = v2592 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v2593 : string = "&*$0"
                                                    let v2594 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2587 v2593 
                                                    let _v2588 = v2594 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v2595 : Ref<Str> = v2587 |> unbox<Ref<Str>>
                                                    let _v2588 = v2595 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v2598 : Ref<Str> = v2587 |> unbox<Ref<Str>>
                                                    let _v2588 = v2598 
                                                    #endif
#else
                                                    let v2601 : Ref<Str> = v2587 |> unbox<Ref<Str>>
                                                    let _v2588 = v2601 
                                                    #endif
                                                    let v2604 : Ref<Str> = _v2588 
                                                    let v2609 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v2610 : string = "String::from($0)"
                                                    let v2611 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2604 v2610 
                                                    let _v2609 = v2611 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v2612 : string = "String::from($0)"
                                                    let v2613 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2604 v2612 
                                                    let _v2609 = v2613 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v2614 : string = "String::from($0)"
                                                    let v2615 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2604 v2614 
                                                    let _v2609 = v2615 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v2616 : std_string_String = v2604 |> unbox<std_string_String>
                                                    let _v2609 = v2616 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v2619 : std_string_String = v2604 |> unbox<std_string_String>
                                                    let _v2609 = v2619 
                                                    #endif
#else
                                                    let v2622 : std_string_String = v2604 |> unbox<std_string_String>
                                                    let _v2609 = v2622 
                                                    #endif
                                                    let v2625 : std_string_String = _v2609 
                                                    let v2630 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v2631 : string = "std::path::PathBuf::from($0)"
                                                    let v2632 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2625 v2631 
                                                    let _v2630 = v2632 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v2633 : string = "std::path::PathBuf::from($0)"
                                                    let v2634 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2625 v2633 
                                                    let _v2630 = v2634 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v2635 : string = "std::path::PathBuf::from($0)"
                                                    let v2636 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2625 v2635 
                                                    let _v2630 = v2636 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v2637 : std_path_PathBuf = v2625 |> std_path_PathBuf 
                                                    let _v2630 = v2637 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v2640 : std_path_PathBuf = v2625 |> std_path_PathBuf 
                                                    let _v2630 = v2640 
                                                    #endif
#else
                                                    let v2643 : std_path_PathBuf = v2625 |> std_path_PathBuf 
                                                    let _v2630 = v2643 
                                                    #endif
                                                    let v2646 : std_path_PathBuf = _v2630 
                                                    let v2651 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v2652 : string = "Ok($0)"
                                                    let v2653 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2646 v2652 
                                                    let _v2651 = v2653 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v2654 : string = "Ok($0)"
                                                    let v2655 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2646 v2654 
                                                    let _v2651 = v2655 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v2656 : string = "Ok($0)"
                                                    let v2657 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2646 v2656 
                                                    let _v2651 = v2657 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v2658 : Result<std_path_PathBuf, std_io_Error> = v2646 |> Ok
                                                    let _v2651 = v2658 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v2659 : Result<std_path_PathBuf, std_io_Error> = v2646 |> Ok
                                                    let _v2651 = v2659 
                                                    #endif
#else
                                                    let v2660 : Result<std_path_PathBuf, std_io_Error> = v2646 |> Ok
                                                    let _v2651 = v2660 
                                                    #endif
                                                    let v2661 : Result<std_path_PathBuf, std_io_Error> = _v2651 
                                                    v2661
                                            else
                                                let v2694 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v103} / path': {v67} / name: {v104}"
                                                let v2695 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2696 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v2697 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2694 v2696 
                                                let _v2695 = v2697 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2698 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v2699 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2694 v2698 
                                                let _v2695 = v2699 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2700 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v2701 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2694 v2700 
                                                let _v2695 = v2701 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2702 : std_io_Error = v2694 
                                                let _v2695 = v2702 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2703 : std_io_Error = v2694 
                                                let _v2695 = v2703 
                                                #endif
#else
                                                let v2704 : std_io_Error = v2694 
                                                let _v2695 = v2704 
                                                #endif
                                                let v2705 : std_io_Error = _v2695 
                                                let v2708 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v2709 : string = "Err($0)"
                                                let v2710 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2705 v2709 
                                                let _v2708 = v2710 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v2711 : string = "Err($0)"
                                                let v2712 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2705 v2711 
                                                let _v2708 = v2712 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v2713 : string = "Err($0)"
                                                let v2714 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2705 v2713 
                                                let _v2708 = v2714 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v2715 : Result<std_path_PathBuf, std_io_Error> = v2705 |> Error
                                                let _v2708 = v2715 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v2716 : Result<std_path_PathBuf, std_io_Error> = v2705 |> Error
                                                let _v2708 = v2716 
                                                #endif
#else
                                                let v2717 : Result<std_path_PathBuf, std_io_Error> = v2705 |> Error
                                                let _v2708 = v2717 
                                                #endif
                                                let v2718 : Result<std_path_PathBuf, std_io_Error> = _v2708 
                                                v2718
                                        | _ ->
                                            let v2722 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v103} / path': {v67} / name: {v104}"
                                            let v2723 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v2724 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v2725 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2722 v2724 
                                            let _v2723 = v2725 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v2726 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v2727 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2722 v2726 
                                            let _v2723 = v2727 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v2728 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v2729 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2722 v2728 
                                            let _v2723 = v2729 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v2730 : std_io_Error = v2722 
                                            let _v2723 = v2730 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v2731 : std_io_Error = v2722 
                                            let _v2723 = v2731 
                                            #endif
#else
                                            let v2732 : std_io_Error = v2722 
                                            let _v2723 = v2732 
                                            #endif
                                            let v2733 : std_io_Error = _v2723 
                                            let v2736 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v2737 : string = "Err($0)"
                                            let v2738 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2733 v2737 
                                            let _v2736 = v2738 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v2739 : string = "Err($0)"
                                            let v2740 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2733 v2739 
                                            let _v2736 = v2740 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v2741 : string = "Err($0)"
                                            let v2742 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2733 v2741 
                                            let _v2736 = v2742 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v2743 : Result<std_path_PathBuf, std_io_Error> = v2733 |> Error
                                            let _v2736 = v2743 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v2744 : Result<std_path_PathBuf, std_io_Error> = v2733 |> Error
                                            let _v2736 = v2744 
                                            #endif
#else
                                            let v2745 : Result<std_path_PathBuf, std_io_Error> = v2733 |> Error
                                            let _v2736 = v2745 
                                            #endif
                                            let v2746 : Result<std_path_PathBuf, std_io_Error> = _v2736 
                                            v2746
                                    | US13_0(v89) -> (* Ok *)
                                        let v90 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v91 : string = "Ok($0)"
                                        let v92 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v89 v91 
                                        let _v90 = v92 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v93 : string = "Ok($0)"
                                        let v94 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v89 v93 
                                        let _v90 = v94 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v95 : string = "Ok($0)"
                                        let v96 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v89 v95 
                                        let _v90 = v96 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v97 : Result<std_path_PathBuf, std_io_Error> = v89 |> Ok
                                        let _v90 = v97 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v98 : Result<std_path_PathBuf, std_io_Error> = v89 |> Ok
                                        let _v90 = v98 
                                        #endif
#else
                                        let v99 : Result<std_path_PathBuf, std_io_Error> = v89 |> Ok
                                        let _v90 = v99 
                                        #endif
                                        let v100 : Result<std_path_PathBuf, std_io_Error> = _v90 
                                        v100
                                let v2752 : (std_io_Error -> string) = method76()
                                let v2753 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2754 : string = "$0.map_err(|x| $1(x))"
                                let v2755 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2751, v2752) v2754 
                                let _v2753 = v2755 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2756 : string = "$0.map_err(|x| $1(x))"
                                let v2757 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2751, v2752) v2756 
                                let _v2753 = v2757 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2758 : string = "$0.map_err(|x| $1(x))"
                                let v2759 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2751, v2752) v2758 
                                let _v2753 = v2759 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2760 : Result<std_path_PathBuf, string> = match v2751 with Ok x -> Ok x | Error x -> Error (v2752 x)
                                let _v2753 = v2760 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2761 : Result<std_path_PathBuf, string> = match v2751 with Ok x -> Ok x | Error x -> Error (v2752 x)
                                let _v2753 = v2761 
                                #endif
#else
                                let v2762 : Result<std_path_PathBuf, string> = match v2751 with Ok x -> Ok x | Error x -> Error (v2752 x)
                                let _v2753 = v2762 
                                #endif
                                let v2763 : Result<std_path_PathBuf, string> = _v2753 
                                let v2766 : US13 = match v2763 with Ok x -> v30 x | Error x -> v31 x
                                match v2766 with
                                | US13_1(v2869) -> (* Error *)
                                    let v2870 : string = $"file_system.read_link / error': {v2869} / error: {v47} / name: {v48}"
                                    let v2871 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v2872 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v2873 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2870 v2872 
                                    let _v2871 = v2873 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v2874 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v2875 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2870 v2874 
                                    let _v2871 = v2875 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v2876 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v2877 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2870 v2876 
                                    let _v2871 = v2877 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v2878 : std_io_Error = v2870 
                                    let _v2871 = v2878 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v2879 : std_io_Error = v2870 
                                    let _v2871 = v2879 
                                    #endif
#else
                                    let v2880 : std_io_Error = v2870 
                                    let _v2871 = v2880 
                                    #endif
                                    let v2881 : std_io_Error = _v2871 
                                    let v2884 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v2885 : string = "Err($0)"
                                    let v2886 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2881 v2885 
                                    let _v2884 = v2886 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v2887 : string = "Err($0)"
                                    let v2888 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2881 v2887 
                                    let _v2884 = v2888 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v2889 : string = "Err($0)"
                                    let v2890 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2881 v2889 
                                    let _v2884 = v2890 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v2891 : Result<std_path_PathBuf, std_io_Error> = v2881 |> Error
                                    let _v2884 = v2891 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v2892 : Result<std_path_PathBuf, std_io_Error> = v2881 |> Error
                                    let _v2884 = v2892 
                                    #endif
#else
                                    let v2893 : Result<std_path_PathBuf, std_io_Error> = v2881 |> Error
                                    let _v2884 = v2893 
                                    #endif
                                    let v2894 : Result<std_path_PathBuf, std_io_Error> = _v2884 
                                    v2894
                                | US13_0(v2767) -> (* Ok *)
                                    let v2768 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v2769 : string = "$0.display()"
                                    let v2770 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2767 v2769 
                                    let _v2768 = v2770 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v2771 : string = "$0.display()"
                                    let v2772 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2767 v2771 
                                    let _v2768 = v2772 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v2773 : string = "$0.display()"
                                    let v2774 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v2767 v2773 
                                    let _v2768 = v2774 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v2775 : std_path_Display = v2767 |> unbox<std_path_Display>
                                    let _v2768 = v2775 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v2778 : std_path_Display = v2767 |> unbox<std_path_Display>
                                    let _v2768 = v2778 
                                    #endif
#else
                                    let v2781 : std_path_Display = v2767 |> unbox<std_path_Display>
                                    let _v2768 = v2781 
                                    #endif
                                    let v2784 : std_path_Display = _v2768 
                                    let v2789 : string = v2784 |> string 
                                    let v2792 : string = method56(v2789, v48)
                                    let v2793 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v2794 : string = "&*$0"
                                    let v2795 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2792 v2794 
                                    let _v2793 = v2795 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v2796 : string = "&*$0"
                                    let v2797 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2792 v2796 
                                    let _v2793 = v2797 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v2798 : string = "&*$0"
                                    let v2799 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v2792 v2798 
                                    let _v2793 = v2799 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v2800 : Ref<Str> = v2792 |> unbox<Ref<Str>>
                                    let _v2793 = v2800 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v2803 : Ref<Str> = v2792 |> unbox<Ref<Str>>
                                    let _v2793 = v2803 
                                    #endif
#else
                                    let v2806 : Ref<Str> = v2792 |> unbox<Ref<Str>>
                                    let _v2793 = v2806 
                                    #endif
                                    let v2809 : Ref<Str> = _v2793 
                                    let v2814 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v2815 : string = "String::from($0)"
                                    let v2816 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2809 v2815 
                                    let _v2814 = v2816 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v2817 : string = "String::from($0)"
                                    let v2818 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2809 v2817 
                                    let _v2814 = v2818 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v2819 : string = "String::from($0)"
                                    let v2820 : std_string_String = Fable.Core.RustInterop.emitRustExpr v2809 v2819 
                                    let _v2814 = v2820 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v2821 : std_string_String = v2809 |> unbox<std_string_String>
                                    let _v2814 = v2821 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v2824 : std_string_String = v2809 |> unbox<std_string_String>
                                    let _v2814 = v2824 
                                    #endif
#else
                                    let v2827 : std_string_String = v2809 |> unbox<std_string_String>
                                    let _v2814 = v2827 
                                    #endif
                                    let v2830 : std_string_String = _v2814 
                                    let v2835 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v2836 : string = "std::path::PathBuf::from($0)"
                                    let v2837 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2830 v2836 
                                    let _v2835 = v2837 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v2838 : string = "std::path::PathBuf::from($0)"
                                    let v2839 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2830 v2838 
                                    let _v2835 = v2839 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v2840 : string = "std::path::PathBuf::from($0)"
                                    let v2841 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v2830 v2840 
                                    let _v2835 = v2841 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v2842 : std_path_PathBuf = v2830 |> std_path_PathBuf 
                                    let _v2835 = v2842 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v2845 : std_path_PathBuf = v2830 |> std_path_PathBuf 
                                    let _v2835 = v2845 
                                    #endif
#else
                                    let v2848 : std_path_PathBuf = v2830 |> std_path_PathBuf 
                                    let _v2835 = v2848 
                                    #endif
                                    let v2851 : std_path_PathBuf = _v2835 
                                    let v2856 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v2857 : string = "Ok($0)"
                                    let v2858 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2851 v2857 
                                    let _v2856 = v2858 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v2859 : string = "Ok($0)"
                                    let v2860 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2851 v2859 
                                    let _v2856 = v2860 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v2861 : string = "Ok($0)"
                                    let v2862 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2851 v2861 
                                    let _v2856 = v2862 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v2863 : Result<std_path_PathBuf, std_io_Error> = v2851 |> Ok
                                    let _v2856 = v2863 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v2864 : Result<std_path_PathBuf, std_io_Error> = v2851 |> Ok
                                    let _v2856 = v2864 
                                    #endif
#else
                                    let v2865 : Result<std_path_PathBuf, std_io_Error> = v2851 |> Ok
                                    let _v2856 = v2865 
                                    #endif
                                    let v2866 : Result<std_path_PathBuf, std_io_Error> = _v2856 
                                    v2866
                            else
                                let v2899 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v47} / path': {v1} / name: {v48}"
                                let v2900 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2901 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v2902 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2899 v2901 
                                let _v2900 = v2902 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2903 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v2904 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2899 v2903 
                                let _v2900 = v2904 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2905 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v2906 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2899 v2905 
                                let _v2900 = v2906 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2907 : std_io_Error = v2899 
                                let _v2900 = v2907 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2908 : std_io_Error = v2899 
                                let _v2900 = v2908 
                                #endif
#else
                                let v2909 : std_io_Error = v2899 
                                let _v2900 = v2909 
                                #endif
                                let v2910 : std_io_Error = _v2900 
                                let v2913 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v2914 : string = "Err($0)"
                                let v2915 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2910 v2914 
                                let _v2913 = v2915 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v2916 : string = "Err($0)"
                                let v2917 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2910 v2916 
                                let _v2913 = v2917 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v2918 : string = "Err($0)"
                                let v2919 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2910 v2918 
                                let _v2913 = v2919 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v2920 : Result<std_path_PathBuf, std_io_Error> = v2910 |> Error
                                let _v2913 = v2920 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v2921 : Result<std_path_PathBuf, std_io_Error> = v2910 |> Error
                                let _v2913 = v2921 
                                #endif
#else
                                let v2922 : Result<std_path_PathBuf, std_io_Error> = v2910 |> Error
                                let _v2913 = v2922 
                                #endif
                                let v2923 : Result<std_path_PathBuf, std_io_Error> = _v2913 
                                v2923
                        | _ ->
                            let v2927 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v47} / path': {v1} / name: {v48}"
                            let v2928 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v2929 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v2930 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2927 v2929 
                            let _v2928 = v2930 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v2931 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v2932 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2927 v2931 
                            let _v2928 = v2932 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v2933 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v2934 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v2927 v2933 
                            let _v2928 = v2934 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v2935 : std_io_Error = v2927 
                            let _v2928 = v2935 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v2936 : std_io_Error = v2927 
                            let _v2928 = v2936 
                            #endif
#else
                            let v2937 : std_io_Error = v2927 
                            let _v2928 = v2937 
                            #endif
                            let v2938 : std_io_Error = _v2928 
                            let v2941 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v2942 : string = "Err($0)"
                            let v2943 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2938 v2942 
                            let _v2941 = v2943 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v2944 : string = "Err($0)"
                            let v2945 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2938 v2944 
                            let _v2941 = v2945 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v2946 : string = "Err($0)"
                            let v2947 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2938 v2946 
                            let _v2941 = v2947 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v2948 : Result<std_path_PathBuf, std_io_Error> = v2938 |> Error
                            let _v2941 = v2948 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v2949 : Result<std_path_PathBuf, std_io_Error> = v2938 |> Error
                            let _v2941 = v2949 
                            #endif
#else
                            let v2950 : Result<std_path_PathBuf, std_io_Error> = v2938 |> Error
                            let _v2941 = v2950 
                            #endif
                            let v2951 : Result<std_path_PathBuf, std_io_Error> = _v2941 
                            v2951
                    | US13_0(v33) -> (* Ok *)
                        let v34 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v35 : string = "Ok($0)"
                        let v36 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v33 v35 
                        let _v34 = v36 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v37 : string = "Ok($0)"
                        let v38 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v33 v37 
                        let _v34 = v38 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v39 : string = "Ok($0)"
                        let v40 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v33 v39 
                        let _v34 = v40 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v41 : Result<std_path_PathBuf, std_io_Error> = v33 |> Ok
                        let _v34 = v41 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v42 : Result<std_path_PathBuf, std_io_Error> = v33 |> Ok
                        let _v34 = v42 
                        #endif
#else
                        let v43 : Result<std_path_PathBuf, std_io_Error> = v33 |> Ok
                        let _v34 = v43 
                        #endif
                        let v44 : Result<std_path_PathBuf, std_io_Error> = _v34 
                        v44
            let _v10 = v2957 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v2958 : bool = method9(v1)
            let v5904 : Result<std_path_PathBuf, std_io_Error> =
                if v2958 then
                    let v2959 : string = "std::fs::read_link(&*$0)"
                    let v2960 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1 v2959 
                    v2960
                else
                    let v2961 : string = "std::fs::read_link(&*$0)"
                    let v2962 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1 v2961 
                    let v2963 : (std_io_Error -> string) = method76()
                    let v2964 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v2965 : string = "$0.map_err(|x| $1(x))"
                    let v2966 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2962, v2963) v2965 
                    let _v2964 = v2966 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v2967 : string = "$0.map_err(|x| $1(x))"
                    let v2968 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2962, v2963) v2967 
                    let _v2964 = v2968 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v2969 : string = "$0.map_err(|x| $1(x))"
                    let v2970 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v2962, v2963) v2969 
                    let _v2964 = v2970 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v2971 : Result<std_path_PathBuf, string> = match v2962 with Ok x -> Ok x | Error x -> Error (v2963 x)
                    let _v2964 = v2971 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v2972 : Result<std_path_PathBuf, string> = match v2962 with Ok x -> Ok x | Error x -> Error (v2963 x)
                    let _v2964 = v2972 
                    #endif
#else
                    let v2973 : Result<std_path_PathBuf, string> = match v2962 with Ok x -> Ok x | Error x -> Error (v2963 x)
                    let _v2964 = v2973 
                    #endif
                    let v2974 : Result<std_path_PathBuf, string> = _v2964 
                    let v2977 : (std_path_PathBuf -> US13) = closure47()
                    let v2978 : (string -> US13) = closure48()
                    let v2979 : US13 = match v2974 with Ok x -> v2977 x | Error x -> v2978 x
                    match v2979 with
                    | US13_1(v2994) -> (* Error *)
                        let v2995 : string = method19(v1)
                        let v2996 : string option = method78(v1)
                        let v2997 : (string -> US1) = method4()
                        let v2998 : US1 option = v2996 |> Option.map v2997 
                        let v3009 : US1 = US1_1
                        let v3010 : US1 = v2998 |> Option.defaultValue v3009 
                        match v3010 with
                        | US1_0(v3014) -> (* Some *)
                            let v3015 : string = ""
                            let v3016 : bool = v1 <> v3015 
                            if v3016 then
                                let v3019 : string = "std::fs::read_link(&*$0)"
                                let v3020 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3014 v3019 
                                let v3021 : (std_io_Error -> string) = method76()
                                let v3022 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v3023 : string = "$0.map_err(|x| $1(x))"
                                let v3024 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3020, v3021) v3023 
                                let _v3022 = v3024 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v3025 : string = "$0.map_err(|x| $1(x))"
                                let v3026 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3020, v3021) v3025 
                                let _v3022 = v3026 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v3027 : string = "$0.map_err(|x| $1(x))"
                                let v3028 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3020, v3021) v3027 
                                let _v3022 = v3028 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v3029 : Result<std_path_PathBuf, string> = match v3020 with Ok x -> Ok x | Error x -> Error (v3021 x)
                                let _v3022 = v3029 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v3030 : Result<std_path_PathBuf, string> = match v3020 with Ok x -> Ok x | Error x -> Error (v3021 x)
                                let _v3022 = v3030 
                                #endif
#else
                                let v3031 : Result<std_path_PathBuf, string> = match v3020 with Ok x -> Ok x | Error x -> Error (v3021 x)
                                let _v3022 = v3031 
                                #endif
                                let v3032 : Result<std_path_PathBuf, string> = _v3022 
                                let v3035 : US13 = match v3032 with Ok x -> v2977 x | Error x -> v2978 x
                                let v5698 : Result<std_path_PathBuf, std_io_Error> =
                                    match v3035 with
                                    | US13_1(v3050) -> (* Error *)
                                        let v3051 : string = method19(v3014)
                                        let v3052 : string option = method78(v3014)
                                        let v3053 : (string -> US1) = method4()
                                        let v3054 : US1 option = v3052 |> Option.map v3053 
                                        let v3065 : US1 = US1_1
                                        let v3066 : US1 = v3054 |> Option.defaultValue v3065 
                                        match v3066 with
                                        | US1_0(v3070) -> (* Some *)
                                            let v3071 : bool = v3014 <> v3015 
                                            if v3071 then
                                                let v3074 : string = "std::fs::read_link(&*$0)"
                                                let v3075 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3070 v3074 
                                                let v3076 : (std_io_Error -> string) = method76()
                                                let v3077 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v3078 : string = "$0.map_err(|x| $1(x))"
                                                let v3079 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3075, v3076) v3078 
                                                let _v3077 = v3079 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v3080 : string = "$0.map_err(|x| $1(x))"
                                                let v3081 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3075, v3076) v3080 
                                                let _v3077 = v3081 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v3082 : string = "$0.map_err(|x| $1(x))"
                                                let v3083 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3075, v3076) v3082 
                                                let _v3077 = v3083 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v3084 : Result<std_path_PathBuf, string> = match v3075 with Ok x -> Ok x | Error x -> Error (v3076 x)
                                                let _v3077 = v3084 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v3085 : Result<std_path_PathBuf, string> = match v3075 with Ok x -> Ok x | Error x -> Error (v3076 x)
                                                let _v3077 = v3085 
                                                #endif
#else
                                                let v3086 : Result<std_path_PathBuf, string> = match v3075 with Ok x -> Ok x | Error x -> Error (v3076 x)
                                                let _v3077 = v3086 
                                                #endif
                                                let v3087 : Result<std_path_PathBuf, string> = _v3077 
                                                let v3090 : US13 = match v3087 with Ok x -> v2977 x | Error x -> v2978 x
                                                let v5493 : Result<std_path_PathBuf, std_io_Error> =
                                                    match v3090 with
                                                    | US13_1(v3105) -> (* Error *)
                                                        let v3106 : string = method19(v3070)
                                                        let v3107 : string option = method78(v3070)
                                                        let v3108 : (string -> US1) = method4()
                                                        let v3109 : US1 option = v3107 |> Option.map v3108 
                                                        let v3120 : US1 = US1_1
                                                        let v3121 : US1 = v3109 |> Option.defaultValue v3120 
                                                        match v3121 with
                                                        | US1_0(v3125) -> (* Some *)
                                                            let v3126 : bool = v3070 <> v3015 
                                                            if v3126 then
                                                                let v3129 : string = "std::fs::read_link(&*$0)"
                                                                let v3130 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3125 v3129 
                                                                let v3131 : (std_io_Error -> string) = method76()
                                                                let v3132 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v3133 : string = "$0.map_err(|x| $1(x))"
                                                                let v3134 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3130, v3131) v3133 
                                                                let _v3132 = v3134 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v3135 : string = "$0.map_err(|x| $1(x))"
                                                                let v3136 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3130, v3131) v3135 
                                                                let _v3132 = v3136 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v3137 : string = "$0.map_err(|x| $1(x))"
                                                                let v3138 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3130, v3131) v3137 
                                                                let _v3132 = v3138 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v3139 : Result<std_path_PathBuf, string> = match v3130 with Ok x -> Ok x | Error x -> Error (v3131 x)
                                                                let _v3132 = v3139 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v3140 : Result<std_path_PathBuf, string> = match v3130 with Ok x -> Ok x | Error x -> Error (v3131 x)
                                                                let _v3132 = v3140 
                                                                #endif
#else
                                                                let v3141 : Result<std_path_PathBuf, string> = match v3130 with Ok x -> Ok x | Error x -> Error (v3131 x)
                                                                let _v3132 = v3141 
                                                                #endif
                                                                let v3142 : Result<std_path_PathBuf, string> = _v3132 
                                                                let v3145 : US13 = match v3142 with Ok x -> v2977 x | Error x -> v2978 x
                                                                let v5288 : Result<std_path_PathBuf, std_io_Error> =
                                                                    match v3145 with
                                                                    | US13_1(v3160) -> (* Error *)
                                                                        let v3161 : string = method19(v3125)
                                                                        let v3162 : string option = method78(v3125)
                                                                        let v3163 : (string -> US1) = method4()
                                                                        let v3164 : US1 option = v3162 |> Option.map v3163 
                                                                        let v3175 : US1 = US1_1
                                                                        let v3176 : US1 = v3164 |> Option.defaultValue v3175 
                                                                        match v3176 with
                                                                        | US1_0(v3180) -> (* Some *)
                                                                            let v3181 : bool = v3125 <> v3015 
                                                                            if v3181 then
                                                                                let v3184 : string = "std::fs::read_link(&*$0)"
                                                                                let v3185 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3180 v3184 
                                                                                let v3186 : (std_io_Error -> string) = method76()
                                                                                let v3187 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v3188 : string = "$0.map_err(|x| $1(x))"
                                                                                let v3189 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3185, v3186) v3188 
                                                                                let _v3187 = v3189 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v3190 : string = "$0.map_err(|x| $1(x))"
                                                                                let v3191 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3185, v3186) v3190 
                                                                                let _v3187 = v3191 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v3192 : string = "$0.map_err(|x| $1(x))"
                                                                                let v3193 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3185, v3186) v3192 
                                                                                let _v3187 = v3193 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v3194 : Result<std_path_PathBuf, string> = match v3185 with Ok x -> Ok x | Error x -> Error (v3186 x)
                                                                                let _v3187 = v3194 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v3195 : Result<std_path_PathBuf, string> = match v3185 with Ok x -> Ok x | Error x -> Error (v3186 x)
                                                                                let _v3187 = v3195 
                                                                                #endif
#else
                                                                                let v3196 : Result<std_path_PathBuf, string> = match v3185 with Ok x -> Ok x | Error x -> Error (v3186 x)
                                                                                let _v3187 = v3196 
                                                                                #endif
                                                                                let v3197 : Result<std_path_PathBuf, string> = _v3187 
                                                                                let v3200 : US13 = match v3197 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                let v5083 : Result<std_path_PathBuf, std_io_Error> =
                                                                                    match v3200 with
                                                                                    | US13_1(v3215) -> (* Error *)
                                                                                        let v3216 : string = method19(v3180)
                                                                                        let v3217 : string option = method78(v3180)
                                                                                        let v3218 : (string -> US1) = method4()
                                                                                        let v3219 : US1 option = v3217 |> Option.map v3218 
                                                                                        let v3230 : US1 = US1_1
                                                                                        let v3231 : US1 = v3219 |> Option.defaultValue v3230 
                                                                                        match v3231 with
                                                                                        | US1_0(v3235) -> (* Some *)
                                                                                            let v3236 : bool = v3180 <> v3015 
                                                                                            if v3236 then
                                                                                                let v3239 : string = "std::fs::read_link(&*$0)"
                                                                                                let v3240 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3235 v3239 
                                                                                                let v3241 : (std_io_Error -> string) = method76()
                                                                                                let v3242 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v3243 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v3244 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3240, v3241) v3243 
                                                                                                let _v3242 = v3244 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v3245 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v3246 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3240, v3241) v3245 
                                                                                                let _v3242 = v3246 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v3247 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v3248 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3240, v3241) v3247 
                                                                                                let _v3242 = v3248 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v3249 : Result<std_path_PathBuf, string> = match v3240 with Ok x -> Ok x | Error x -> Error (v3241 x)
                                                                                                let _v3242 = v3249 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v3250 : Result<std_path_PathBuf, string> = match v3240 with Ok x -> Ok x | Error x -> Error (v3241 x)
                                                                                                let _v3242 = v3250 
                                                                                                #endif
#else
                                                                                                let v3251 : Result<std_path_PathBuf, string> = match v3240 with Ok x -> Ok x | Error x -> Error (v3241 x)
                                                                                                let _v3242 = v3251 
                                                                                                #endif
                                                                                                let v3252 : Result<std_path_PathBuf, string> = _v3242 
                                                                                                let v3255 : US13 = match v3252 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                let v4878 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                    match v3255 with
                                                                                                    | US13_1(v3270) -> (* Error *)
                                                                                                        let v3271 : string = method19(v3235)
                                                                                                        let v3272 : string option = method78(v3235)
                                                                                                        let v3273 : (string -> US1) = method4()
                                                                                                        let v3274 : US1 option = v3272 |> Option.map v3273 
                                                                                                        let v3285 : US1 = US1_1
                                                                                                        let v3286 : US1 = v3274 |> Option.defaultValue v3285 
                                                                                                        match v3286 with
                                                                                                        | US1_0(v3290) -> (* Some *)
                                                                                                            let v3291 : bool = v3235 <> v3015 
                                                                                                            if v3291 then
                                                                                                                let v3294 : string = "std::fs::read_link(&*$0)"
                                                                                                                let v3295 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3290 v3294 
                                                                                                                let v3296 : (std_io_Error -> string) = method76()
                                                                                                                let v3297 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v3298 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v3299 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3295, v3296) v3298 
                                                                                                                let _v3297 = v3299 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v3300 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v3301 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3295, v3296) v3300 
                                                                                                                let _v3297 = v3301 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v3302 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v3303 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3295, v3296) v3302 
                                                                                                                let _v3297 = v3303 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v3304 : Result<std_path_PathBuf, string> = match v3295 with Ok x -> Ok x | Error x -> Error (v3296 x)
                                                                                                                let _v3297 = v3304 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v3305 : Result<std_path_PathBuf, string> = match v3295 with Ok x -> Ok x | Error x -> Error (v3296 x)
                                                                                                                let _v3297 = v3305 
                                                                                                                #endif
#else
                                                                                                                let v3306 : Result<std_path_PathBuf, string> = match v3295 with Ok x -> Ok x | Error x -> Error (v3296 x)
                                                                                                                let _v3297 = v3306 
                                                                                                                #endif
                                                                                                                let v3307 : Result<std_path_PathBuf, string> = _v3297 
                                                                                                                let v3310 : US13 = match v3307 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                let v4673 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                    match v3310 with
                                                                                                                    | US13_1(v3325) -> (* Error *)
                                                                                                                        let v3326 : string = method19(v3290)
                                                                                                                        let v3327 : string option = method78(v3290)
                                                                                                                        let v3328 : (string -> US1) = method4()
                                                                                                                        let v3329 : US1 option = v3327 |> Option.map v3328 
                                                                                                                        let v3340 : US1 = US1_1
                                                                                                                        let v3341 : US1 = v3329 |> Option.defaultValue v3340 
                                                                                                                        match v3341 with
                                                                                                                        | US1_0(v3345) -> (* Some *)
                                                                                                                            let v3346 : bool = v3290 <> v3015 
                                                                                                                            if v3346 then
                                                                                                                                let v3349 : string = "std::fs::read_link(&*$0)"
                                                                                                                                let v3350 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3345 v3349 
                                                                                                                                let v3351 : (std_io_Error -> string) = method76()
                                                                                                                                let v3352 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v3353 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v3354 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3350, v3351) v3353 
                                                                                                                                let _v3352 = v3354 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v3355 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v3356 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3350, v3351) v3355 
                                                                                                                                let _v3352 = v3356 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v3357 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v3358 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3350, v3351) v3357 
                                                                                                                                let _v3352 = v3358 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v3359 : Result<std_path_PathBuf, string> = match v3350 with Ok x -> Ok x | Error x -> Error (v3351 x)
                                                                                                                                let _v3352 = v3359 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v3360 : Result<std_path_PathBuf, string> = match v3350 with Ok x -> Ok x | Error x -> Error (v3351 x)
                                                                                                                                let _v3352 = v3360 
                                                                                                                                #endif
#else
                                                                                                                                let v3361 : Result<std_path_PathBuf, string> = match v3350 with Ok x -> Ok x | Error x -> Error (v3351 x)
                                                                                                                                let _v3352 = v3361 
                                                                                                                                #endif
                                                                                                                                let v3362 : Result<std_path_PathBuf, string> = _v3352 
                                                                                                                                let v3365 : US13 = match v3362 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                let v4468 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                    match v3365 with
                                                                                                                                    | US13_1(v3380) -> (* Error *)
                                                                                                                                        let v3381 : string = method19(v3345)
                                                                                                                                        let v3382 : string option = method78(v3345)
                                                                                                                                        let v3383 : (string -> US1) = method4()
                                                                                                                                        let v3384 : US1 option = v3382 |> Option.map v3383 
                                                                                                                                        let v3395 : US1 = US1_1
                                                                                                                                        let v3396 : US1 = v3384 |> Option.defaultValue v3395 
                                                                                                                                        match v3396 with
                                                                                                                                        | US1_0(v3400) -> (* Some *)
                                                                                                                                            let v3401 : bool = v3345 <> v3015 
                                                                                                                                            if v3401 then
                                                                                                                                                let v3404 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                let v3405 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3400 v3404 
                                                                                                                                                let v3406 : (std_io_Error -> string) = method76()
                                                                                                                                                let v3407 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v3408 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v3409 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3405, v3406) v3408 
                                                                                                                                                let _v3407 = v3409 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v3410 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v3411 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3405, v3406) v3410 
                                                                                                                                                let _v3407 = v3411 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v3412 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v3413 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3405, v3406) v3412 
                                                                                                                                                let _v3407 = v3413 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v3414 : Result<std_path_PathBuf, string> = match v3405 with Ok x -> Ok x | Error x -> Error (v3406 x)
                                                                                                                                                let _v3407 = v3414 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v3415 : Result<std_path_PathBuf, string> = match v3405 with Ok x -> Ok x | Error x -> Error (v3406 x)
                                                                                                                                                let _v3407 = v3415 
                                                                                                                                                #endif
#else
                                                                                                                                                let v3416 : Result<std_path_PathBuf, string> = match v3405 with Ok x -> Ok x | Error x -> Error (v3406 x)
                                                                                                                                                let _v3407 = v3416 
                                                                                                                                                #endif
                                                                                                                                                let v3417 : Result<std_path_PathBuf, string> = _v3407 
                                                                                                                                                let v3420 : US13 = match v3417 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                                let v4263 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                    match v3420 with
                                                                                                                                                    | US13_1(v3435) -> (* Error *)
                                                                                                                                                        let v3436 : string = method19(v3400)
                                                                                                                                                        let v3437 : string option = method78(v3400)
                                                                                                                                                        let v3438 : (string -> US1) = method4()
                                                                                                                                                        let v3439 : US1 option = v3437 |> Option.map v3438 
                                                                                                                                                        let v3450 : US1 = US1_1
                                                                                                                                                        let v3451 : US1 = v3439 |> Option.defaultValue v3450 
                                                                                                                                                        match v3451 with
                                                                                                                                                        | US1_0(v3455) -> (* Some *)
                                                                                                                                                            let v3456 : bool = v3400 <> v3015 
                                                                                                                                                            if v3456 then
                                                                                                                                                                let v3459 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                let v3460 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3455 v3459 
                                                                                                                                                                let v3461 : (std_io_Error -> string) = method76()
                                                                                                                                                                let v3462 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v3463 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v3464 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3460, v3461) v3463 
                                                                                                                                                                let _v3462 = v3464 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v3465 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v3466 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3460, v3461) v3465 
                                                                                                                                                                let _v3462 = v3466 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v3467 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v3468 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3460, v3461) v3467 
                                                                                                                                                                let _v3462 = v3468 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v3469 : Result<std_path_PathBuf, string> = match v3460 with Ok x -> Ok x | Error x -> Error (v3461 x)
                                                                                                                                                                let _v3462 = v3469 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v3470 : Result<std_path_PathBuf, string> = match v3460 with Ok x -> Ok x | Error x -> Error (v3461 x)
                                                                                                                                                                let _v3462 = v3470 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v3471 : Result<std_path_PathBuf, string> = match v3460 with Ok x -> Ok x | Error x -> Error (v3461 x)
                                                                                                                                                                let _v3462 = v3471 
                                                                                                                                                                #endif
                                                                                                                                                                let v3472 : Result<std_path_PathBuf, string> = _v3462 
                                                                                                                                                                let v3475 : US13 = match v3472 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                                                let v4058 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                    match v3475 with
                                                                                                                                                                    | US13_1(v3490) -> (* Error *)
                                                                                                                                                                        let v3491 : string = method19(v3455)
                                                                                                                                                                        let v3492 : string option = method78(v3455)
                                                                                                                                                                        let v3493 : (string -> US1) = method4()
                                                                                                                                                                        let v3494 : US1 option = v3492 |> Option.map v3493 
                                                                                                                                                                        let v3505 : US1 = US1_1
                                                                                                                                                                        let v3506 : US1 = v3494 |> Option.defaultValue v3505 
                                                                                                                                                                        match v3506 with
                                                                                                                                                                        | US1_0(v3510) -> (* Some *)
                                                                                                                                                                            let v3511 : bool = v3455 <> v3015 
                                                                                                                                                                            if v3511 then
                                                                                                                                                                                let v3514 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                let v3515 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3510 v3514 
                                                                                                                                                                                let v3516 : (std_io_Error -> string) = method76()
                                                                                                                                                                                let v3517 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3518 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v3519 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3515, v3516) v3518 
                                                                                                                                                                                let _v3517 = v3519 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3520 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v3521 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3515, v3516) v3520 
                                                                                                                                                                                let _v3517 = v3521 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3522 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v3523 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3515, v3516) v3522 
                                                                                                                                                                                let _v3517 = v3523 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3524 : Result<std_path_PathBuf, string> = match v3515 with Ok x -> Ok x | Error x -> Error (v3516 x)
                                                                                                                                                                                let _v3517 = v3524 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3525 : Result<std_path_PathBuf, string> = match v3515 with Ok x -> Ok x | Error x -> Error (v3516 x)
                                                                                                                                                                                let _v3517 = v3525 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3526 : Result<std_path_PathBuf, string> = match v3515 with Ok x -> Ok x | Error x -> Error (v3516 x)
                                                                                                                                                                                let _v3517 = v3526 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3527 : Result<std_path_PathBuf, string> = _v3517 
                                                                                                                                                                                let v3530 : US13 = match v3527 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                                                                let v3853 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                    match v3530 with
                                                                                                                                                                                    | US13_1(v3545) -> (* Error *)
                                                                                                                                                                                        let v3546 : string = method19(v3510)
                                                                                                                                                                                        let v3547 : string option = method78(v3510)
                                                                                                                                                                                        let v3548 : (string -> US1) = method4()
                                                                                                                                                                                        let v3549 : US1 option = v3547 |> Option.map v3548 
                                                                                                                                                                                        let v3560 : US1 = US1_1
                                                                                                                                                                                        let v3561 : US1 = v3549 |> Option.defaultValue v3560 
                                                                                                                                                                                        match v3561 with
                                                                                                                                                                                        | US1_0(v3565) -> (* Some *)
                                                                                                                                                                                            let v3566 : bool = v3510 <> v3015 
                                                                                                                                                                                            if v3566 then
                                                                                                                                                                                                let v3569 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                                let v3570 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3565 v3569 
                                                                                                                                                                                                let v3571 : (std_io_Error -> string) = method76()
                                                                                                                                                                                                let v3572 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3573 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v3574 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3570, v3571) v3573 
                                                                                                                                                                                                let _v3572 = v3574 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3575 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v3576 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3570, v3571) v3575 
                                                                                                                                                                                                let _v3572 = v3576 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3577 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v3578 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3570, v3571) v3577 
                                                                                                                                                                                                let _v3572 = v3578 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3579 : Result<std_path_PathBuf, string> = match v3570 with Ok x -> Ok x | Error x -> Error (v3571 x)
                                                                                                                                                                                                let _v3572 = v3579 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3580 : Result<std_path_PathBuf, string> = match v3570 with Ok x -> Ok x | Error x -> Error (v3571 x)
                                                                                                                                                                                                let _v3572 = v3580 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3581 : Result<std_path_PathBuf, string> = match v3570 with Ok x -> Ok x | Error x -> Error (v3571 x)
                                                                                                                                                                                                let _v3572 = v3581 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3582 : Result<std_path_PathBuf, string> = _v3572 
                                                                                                                                                                                                let v3585 : US13 = match v3582 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                                                                                let v3648 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                    match v3585 with
                                                                                                                                                                                                    | US13_1(v3600) -> (* Error *)
                                                                                                                                                                                                        let v3601 : string = method19(v3565)
                                                                                                                                                                                                        let v3602 : string option = method78(v3565)
                                                                                                                                                                                                        let v3603 : (string -> US1) = method4()
                                                                                                                                                                                                        let v3604 : US1 option = v3602 |> Option.map v3603 
                                                                                                                                                                                                        let v3615 : US1 = US1_1
                                                                                                                                                                                                        let v3616 : US1 = v3604 |> Option.defaultValue v3615 
                                                                                                                                                                                                        let v3620 : string = $"file_system.read_link / path: {v1} / n: {11uy} / path': {v3565} / name: {v3601}"
                                                                                                                                                                                                        let v3621 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v3622 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v3623 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3620 v3622 
                                                                                                                                                                                                        let _v3621 = v3623 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v3624 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v3625 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3620 v3624 
                                                                                                                                                                                                        let _v3621 = v3625 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v3626 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v3627 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3620 v3626 
                                                                                                                                                                                                        let _v3621 = v3627 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v3628 : std_io_Error = v3620 
                                                                                                                                                                                                        let _v3621 = v3628 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v3629 : std_io_Error = v3620 
                                                                                                                                                                                                        let _v3621 = v3629 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v3630 : std_io_Error = v3620 
                                                                                                                                                                                                        let _v3621 = v3630 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v3631 : std_io_Error = _v3621 
                                                                                                                                                                                                        let v3634 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v3635 : string = "Err($0)"
                                                                                                                                                                                                        let v3636 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3631 v3635 
                                                                                                                                                                                                        let _v3634 = v3636 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v3637 : string = "Err($0)"
                                                                                                                                                                                                        let v3638 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3631 v3637 
                                                                                                                                                                                                        let _v3634 = v3638 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v3639 : string = "Err($0)"
                                                                                                                                                                                                        let v3640 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3631 v3639 
                                                                                                                                                                                                        let _v3634 = v3640 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v3641 : Result<std_path_PathBuf, std_io_Error> = v3631 |> Error
                                                                                                                                                                                                        let _v3634 = v3641 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v3642 : Result<std_path_PathBuf, std_io_Error> = v3631 |> Error
                                                                                                                                                                                                        let _v3634 = v3642 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v3643 : Result<std_path_PathBuf, std_io_Error> = v3631 |> Error
                                                                                                                                                                                                        let _v3634 = v3643 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v3644 : Result<std_path_PathBuf, std_io_Error> = _v3634 
                                                                                                                                                                                                        v3644
                                                                                                                                                                                                    | US13_0(v3586) -> (* Ok *)
                                                                                                                                                                                                        let v3587 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v3588 : string = "Ok($0)"
                                                                                                                                                                                                        let v3589 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3586 v3588 
                                                                                                                                                                                                        let _v3587 = v3589 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v3590 : string = "Ok($0)"
                                                                                                                                                                                                        let v3591 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3586 v3590 
                                                                                                                                                                                                        let _v3587 = v3591 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v3592 : string = "Ok($0)"
                                                                                                                                                                                                        let v3593 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3586 v3592 
                                                                                                                                                                                                        let _v3587 = v3593 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v3594 : Result<std_path_PathBuf, std_io_Error> = v3586 |> Ok
                                                                                                                                                                                                        let _v3587 = v3594 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v3595 : Result<std_path_PathBuf, std_io_Error> = v3586 |> Ok
                                                                                                                                                                                                        let _v3587 = v3595 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v3596 : Result<std_path_PathBuf, std_io_Error> = v3586 |> Ok
                                                                                                                                                                                                        let _v3587 = v3596 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v3597 : Result<std_path_PathBuf, std_io_Error> = _v3587 
                                                                                                                                                                                                        v3597
                                                                                                                                                                                                let v3649 : (std_io_Error -> string) = method76()
                                                                                                                                                                                                let v3650 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3651 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v3652 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3648, v3649) v3651 
                                                                                                                                                                                                let _v3650 = v3652 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3653 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v3654 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3648, v3649) v3653 
                                                                                                                                                                                                let _v3650 = v3654 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3655 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v3656 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3648, v3649) v3655 
                                                                                                                                                                                                let _v3650 = v3656 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3657 : Result<std_path_PathBuf, string> = match v3648 with Ok x -> Ok x | Error x -> Error (v3649 x)
                                                                                                                                                                                                let _v3650 = v3657 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3658 : Result<std_path_PathBuf, string> = match v3648 with Ok x -> Ok x | Error x -> Error (v3649 x)
                                                                                                                                                                                                let _v3650 = v3658 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3659 : Result<std_path_PathBuf, string> = match v3648 with Ok x -> Ok x | Error x -> Error (v3649 x)
                                                                                                                                                                                                let _v3650 = v3659 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3660 : Result<std_path_PathBuf, string> = _v3650 
                                                                                                                                                                                                let v3663 : US13 = match v3660 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                                                                                match v3663 with
                                                                                                                                                                                                | US13_1(v3766) -> (* Error *)
                                                                                                                                                                                                    let v3767 : string = $"file_system.read_link / error': {v3766} / error: {v3545} / name: {v3546}"
                                                                                                                                                                                                    let v3768 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3769 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v3770 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3767 v3769 
                                                                                                                                                                                                    let _v3768 = v3770 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3771 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v3772 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3767 v3771 
                                                                                                                                                                                                    let _v3768 = v3772 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3773 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v3774 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3767 v3773 
                                                                                                                                                                                                    let _v3768 = v3774 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3775 : std_io_Error = v3767 
                                                                                                                                                                                                    let _v3768 = v3775 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3776 : std_io_Error = v3767 
                                                                                                                                                                                                    let _v3768 = v3776 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3777 : std_io_Error = v3767 
                                                                                                                                                                                                    let _v3768 = v3777 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3778 : std_io_Error = _v3768 
                                                                                                                                                                                                    let v3781 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3782 : string = "Err($0)"
                                                                                                                                                                                                    let v3783 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3778 v3782 
                                                                                                                                                                                                    let _v3781 = v3783 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3784 : string = "Err($0)"
                                                                                                                                                                                                    let v3785 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3778 v3784 
                                                                                                                                                                                                    let _v3781 = v3785 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3786 : string = "Err($0)"
                                                                                                                                                                                                    let v3787 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3778 v3786 
                                                                                                                                                                                                    let _v3781 = v3787 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3788 : Result<std_path_PathBuf, std_io_Error> = v3778 |> Error
                                                                                                                                                                                                    let _v3781 = v3788 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3789 : Result<std_path_PathBuf, std_io_Error> = v3778 |> Error
                                                                                                                                                                                                    let _v3781 = v3789 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3790 : Result<std_path_PathBuf, std_io_Error> = v3778 |> Error
                                                                                                                                                                                                    let _v3781 = v3790 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3791 : Result<std_path_PathBuf, std_io_Error> = _v3781 
                                                                                                                                                                                                    v3791
                                                                                                                                                                                                | US13_0(v3664) -> (* Ok *)
                                                                                                                                                                                                    let v3665 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3666 : string = "$0.display()"
                                                                                                                                                                                                    let v3667 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3664 v3666 
                                                                                                                                                                                                    let _v3665 = v3667 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3668 : string = "$0.display()"
                                                                                                                                                                                                    let v3669 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3664 v3668 
                                                                                                                                                                                                    let _v3665 = v3669 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3670 : string = "$0.display()"
                                                                                                                                                                                                    let v3671 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3664 v3670 
                                                                                                                                                                                                    let _v3665 = v3671 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3672 : std_path_Display = v3664 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v3665 = v3672 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3675 : std_path_Display = v3664 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v3665 = v3675 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3678 : std_path_Display = v3664 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v3665 = v3678 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3681 : std_path_Display = _v3665 
                                                                                                                                                                                                    let v3686 : string = v3681 |> string 
                                                                                                                                                                                                    let v3689 : string = method56(v3686, v3546)
                                                                                                                                                                                                    let v3690 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3691 : string = "&*$0"
                                                                                                                                                                                                    let v3692 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3689 v3691 
                                                                                                                                                                                                    let _v3690 = v3692 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3693 : string = "&*$0"
                                                                                                                                                                                                    let v3694 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3689 v3693 
                                                                                                                                                                                                    let _v3690 = v3694 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3695 : string = "&*$0"
                                                                                                                                                                                                    let v3696 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3689 v3695 
                                                                                                                                                                                                    let _v3690 = v3696 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3697 : Ref<Str> = v3689 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v3690 = v3697 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3700 : Ref<Str> = v3689 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v3690 = v3700 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3703 : Ref<Str> = v3689 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v3690 = v3703 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3706 : Ref<Str> = _v3690 
                                                                                                                                                                                                    let v3711 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3712 : string = "String::from($0)"
                                                                                                                                                                                                    let v3713 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3706 v3712 
                                                                                                                                                                                                    let _v3711 = v3713 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3714 : string = "String::from($0)"
                                                                                                                                                                                                    let v3715 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3706 v3714 
                                                                                                                                                                                                    let _v3711 = v3715 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3716 : string = "String::from($0)"
                                                                                                                                                                                                    let v3717 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3706 v3716 
                                                                                                                                                                                                    let _v3711 = v3717 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3718 : std_string_String = v3706 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v3711 = v3718 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3721 : std_string_String = v3706 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v3711 = v3721 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3724 : std_string_String = v3706 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v3711 = v3724 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3727 : std_string_String = _v3711 
                                                                                                                                                                                                    let v3732 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3733 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v3734 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3727 v3733 
                                                                                                                                                                                                    let _v3732 = v3734 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3735 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v3736 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3727 v3735 
                                                                                                                                                                                                    let _v3732 = v3736 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3737 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v3738 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3727 v3737 
                                                                                                                                                                                                    let _v3732 = v3738 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3739 : std_path_PathBuf = v3727 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v3732 = v3739 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3742 : std_path_PathBuf = v3727 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v3732 = v3742 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3745 : std_path_PathBuf = v3727 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v3732 = v3745 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3748 : std_path_PathBuf = _v3732 
                                                                                                                                                                                                    let v3753 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v3754 : string = "Ok($0)"
                                                                                                                                                                                                    let v3755 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3748 v3754 
                                                                                                                                                                                                    let _v3753 = v3755 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v3756 : string = "Ok($0)"
                                                                                                                                                                                                    let v3757 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3748 v3756 
                                                                                                                                                                                                    let _v3753 = v3757 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v3758 : string = "Ok($0)"
                                                                                                                                                                                                    let v3759 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3748 v3758 
                                                                                                                                                                                                    let _v3753 = v3759 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v3760 : Result<std_path_PathBuf, std_io_Error> = v3748 |> Ok
                                                                                                                                                                                                    let _v3753 = v3760 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v3761 : Result<std_path_PathBuf, std_io_Error> = v3748 |> Ok
                                                                                                                                                                                                    let _v3753 = v3761 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v3762 : Result<std_path_PathBuf, std_io_Error> = v3748 |> Ok
                                                                                                                                                                                                    let _v3753 = v3762 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v3763 : Result<std_path_PathBuf, std_io_Error> = _v3753 
                                                                                                                                                                                                    v3763
                                                                                                                                                                                            else
                                                                                                                                                                                                let v3796 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3545} / path': {v3510} / name: {v3546}"
                                                                                                                                                                                                let v3797 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3798 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v3799 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3796 v3798 
                                                                                                                                                                                                let _v3797 = v3799 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3800 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v3801 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3796 v3800 
                                                                                                                                                                                                let _v3797 = v3801 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3802 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v3803 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3796 v3802 
                                                                                                                                                                                                let _v3797 = v3803 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3804 : std_io_Error = v3796 
                                                                                                                                                                                                let _v3797 = v3804 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3805 : std_io_Error = v3796 
                                                                                                                                                                                                let _v3797 = v3805 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3806 : std_io_Error = v3796 
                                                                                                                                                                                                let _v3797 = v3806 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3807 : std_io_Error = _v3797 
                                                                                                                                                                                                let v3810 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v3811 : string = "Err($0)"
                                                                                                                                                                                                let v3812 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3807 v3811 
                                                                                                                                                                                                let _v3810 = v3812 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v3813 : string = "Err($0)"
                                                                                                                                                                                                let v3814 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3807 v3813 
                                                                                                                                                                                                let _v3810 = v3814 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v3815 : string = "Err($0)"
                                                                                                                                                                                                let v3816 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3807 v3815 
                                                                                                                                                                                                let _v3810 = v3816 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v3817 : Result<std_path_PathBuf, std_io_Error> = v3807 |> Error
                                                                                                                                                                                                let _v3810 = v3817 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v3818 : Result<std_path_PathBuf, std_io_Error> = v3807 |> Error
                                                                                                                                                                                                let _v3810 = v3818 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v3819 : Result<std_path_PathBuf, std_io_Error> = v3807 |> Error
                                                                                                                                                                                                let _v3810 = v3819 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v3820 : Result<std_path_PathBuf, std_io_Error> = _v3810 
                                                                                                                                                                                                v3820
                                                                                                                                                                                        | _ ->
                                                                                                                                                                                            let v3824 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3545} / path': {v3510} / name: {v3546}"
                                                                                                                                                                                            let v3825 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v3826 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v3827 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3824 v3826 
                                                                                                                                                                                            let _v3825 = v3827 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v3828 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v3829 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3824 v3828 
                                                                                                                                                                                            let _v3825 = v3829 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v3830 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v3831 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3824 v3830 
                                                                                                                                                                                            let _v3825 = v3831 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v3832 : std_io_Error = v3824 
                                                                                                                                                                                            let _v3825 = v3832 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v3833 : std_io_Error = v3824 
                                                                                                                                                                                            let _v3825 = v3833 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v3834 : std_io_Error = v3824 
                                                                                                                                                                                            let _v3825 = v3834 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v3835 : std_io_Error = _v3825 
                                                                                                                                                                                            let v3838 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v3839 : string = "Err($0)"
                                                                                                                                                                                            let v3840 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3835 v3839 
                                                                                                                                                                                            let _v3838 = v3840 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v3841 : string = "Err($0)"
                                                                                                                                                                                            let v3842 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3835 v3841 
                                                                                                                                                                                            let _v3838 = v3842 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v3843 : string = "Err($0)"
                                                                                                                                                                                            let v3844 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3835 v3843 
                                                                                                                                                                                            let _v3838 = v3844 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v3845 : Result<std_path_PathBuf, std_io_Error> = v3835 |> Error
                                                                                                                                                                                            let _v3838 = v3845 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v3846 : Result<std_path_PathBuf, std_io_Error> = v3835 |> Error
                                                                                                                                                                                            let _v3838 = v3846 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v3847 : Result<std_path_PathBuf, std_io_Error> = v3835 |> Error
                                                                                                                                                                                            let _v3838 = v3847 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v3848 : Result<std_path_PathBuf, std_io_Error> = _v3838 
                                                                                                                                                                                            v3848
                                                                                                                                                                                    | US13_0(v3531) -> (* Ok *)
                                                                                                                                                                                        let v3532 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v3533 : string = "Ok($0)"
                                                                                                                                                                                        let v3534 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3531 v3533 
                                                                                                                                                                                        let _v3532 = v3534 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v3535 : string = "Ok($0)"
                                                                                                                                                                                        let v3536 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3531 v3535 
                                                                                                                                                                                        let _v3532 = v3536 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v3537 : string = "Ok($0)"
                                                                                                                                                                                        let v3538 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3531 v3537 
                                                                                                                                                                                        let _v3532 = v3538 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v3539 : Result<std_path_PathBuf, std_io_Error> = v3531 |> Ok
                                                                                                                                                                                        let _v3532 = v3539 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v3540 : Result<std_path_PathBuf, std_io_Error> = v3531 |> Ok
                                                                                                                                                                                        let _v3532 = v3540 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v3541 : Result<std_path_PathBuf, std_io_Error> = v3531 |> Ok
                                                                                                                                                                                        let _v3532 = v3541 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v3542 : Result<std_path_PathBuf, std_io_Error> = _v3532 
                                                                                                                                                                                        v3542
                                                                                                                                                                                let v3854 : (std_io_Error -> string) = method76()
                                                                                                                                                                                let v3855 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v3856 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v3857 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3853, v3854) v3856 
                                                                                                                                                                                let _v3855 = v3857 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v3858 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v3859 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3853, v3854) v3858 
                                                                                                                                                                                let _v3855 = v3859 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v3860 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v3861 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v3853, v3854) v3860 
                                                                                                                                                                                let _v3855 = v3861 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v3862 : Result<std_path_PathBuf, string> = match v3853 with Ok x -> Ok x | Error x -> Error (v3854 x)
                                                                                                                                                                                let _v3855 = v3862 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v3863 : Result<std_path_PathBuf, string> = match v3853 with Ok x -> Ok x | Error x -> Error (v3854 x)
                                                                                                                                                                                let _v3855 = v3863 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v3864 : Result<std_path_PathBuf, string> = match v3853 with Ok x -> Ok x | Error x -> Error (v3854 x)
                                                                                                                                                                                let _v3855 = v3864 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v3865 : Result<std_path_PathBuf, string> = _v3855 
                                                                                                                                                                                let v3868 : US13 = match v3865 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                                                                match v3868 with
                                                                                                                                                                                | US13_1(v3971) -> (* Error *)
                                                                                                                                                                                    let v3972 : string = $"file_system.read_link / error': {v3971} / error: {v3490} / name: {v3491}"
                                                                                                                                                                                    let v3973 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v3974 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v3975 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3972 v3974 
                                                                                                                                                                                    let _v3973 = v3975 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v3976 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v3977 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3972 v3976 
                                                                                                                                                                                    let _v3973 = v3977 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v3978 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v3979 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v3972 v3978 
                                                                                                                                                                                    let _v3973 = v3979 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v3980 : std_io_Error = v3972 
                                                                                                                                                                                    let _v3973 = v3980 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v3981 : std_io_Error = v3972 
                                                                                                                                                                                    let _v3973 = v3981 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v3982 : std_io_Error = v3972 
                                                                                                                                                                                    let _v3973 = v3982 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v3983 : std_io_Error = _v3973 
                                                                                                                                                                                    let v3986 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v3987 : string = "Err($0)"
                                                                                                                                                                                    let v3988 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3983 v3987 
                                                                                                                                                                                    let _v3986 = v3988 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v3989 : string = "Err($0)"
                                                                                                                                                                                    let v3990 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3983 v3989 
                                                                                                                                                                                    let _v3986 = v3990 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v3991 : string = "Err($0)"
                                                                                                                                                                                    let v3992 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3983 v3991 
                                                                                                                                                                                    let _v3986 = v3992 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v3993 : Result<std_path_PathBuf, std_io_Error> = v3983 |> Error
                                                                                                                                                                                    let _v3986 = v3993 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v3994 : Result<std_path_PathBuf, std_io_Error> = v3983 |> Error
                                                                                                                                                                                    let _v3986 = v3994 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v3995 : Result<std_path_PathBuf, std_io_Error> = v3983 |> Error
                                                                                                                                                                                    let _v3986 = v3995 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v3996 : Result<std_path_PathBuf, std_io_Error> = _v3986 
                                                                                                                                                                                    v3996
                                                                                                                                                                                | US13_0(v3869) -> (* Ok *)
                                                                                                                                                                                    let v3870 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v3871 : string = "$0.display()"
                                                                                                                                                                                    let v3872 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3869 v3871 
                                                                                                                                                                                    let _v3870 = v3872 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v3873 : string = "$0.display()"
                                                                                                                                                                                    let v3874 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3869 v3873 
                                                                                                                                                                                    let _v3870 = v3874 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v3875 : string = "$0.display()"
                                                                                                                                                                                    let v3876 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v3869 v3875 
                                                                                                                                                                                    let _v3870 = v3876 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v3877 : std_path_Display = v3869 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v3870 = v3877 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v3880 : std_path_Display = v3869 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v3870 = v3880 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v3883 : std_path_Display = v3869 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v3870 = v3883 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v3886 : std_path_Display = _v3870 
                                                                                                                                                                                    let v3891 : string = v3886 |> string 
                                                                                                                                                                                    let v3894 : string = method56(v3891, v3491)
                                                                                                                                                                                    let v3895 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v3896 : string = "&*$0"
                                                                                                                                                                                    let v3897 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3894 v3896 
                                                                                                                                                                                    let _v3895 = v3897 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v3898 : string = "&*$0"
                                                                                                                                                                                    let v3899 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3894 v3898 
                                                                                                                                                                                    let _v3895 = v3899 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v3900 : string = "&*$0"
                                                                                                                                                                                    let v3901 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v3894 v3900 
                                                                                                                                                                                    let _v3895 = v3901 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v3902 : Ref<Str> = v3894 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v3895 = v3902 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v3905 : Ref<Str> = v3894 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v3895 = v3905 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v3908 : Ref<Str> = v3894 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v3895 = v3908 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v3911 : Ref<Str> = _v3895 
                                                                                                                                                                                    let v3916 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v3917 : string = "String::from($0)"
                                                                                                                                                                                    let v3918 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3911 v3917 
                                                                                                                                                                                    let _v3916 = v3918 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v3919 : string = "String::from($0)"
                                                                                                                                                                                    let v3920 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3911 v3919 
                                                                                                                                                                                    let _v3916 = v3920 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v3921 : string = "String::from($0)"
                                                                                                                                                                                    let v3922 : std_string_String = Fable.Core.RustInterop.emitRustExpr v3911 v3921 
                                                                                                                                                                                    let _v3916 = v3922 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v3923 : std_string_String = v3911 |> unbox<std_string_String>
                                                                                                                                                                                    let _v3916 = v3923 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v3926 : std_string_String = v3911 |> unbox<std_string_String>
                                                                                                                                                                                    let _v3916 = v3926 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v3929 : std_string_String = v3911 |> unbox<std_string_String>
                                                                                                                                                                                    let _v3916 = v3929 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v3932 : std_string_String = _v3916 
                                                                                                                                                                                    let v3937 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v3938 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v3939 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3932 v3938 
                                                                                                                                                                                    let _v3937 = v3939 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v3940 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v3941 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3932 v3940 
                                                                                                                                                                                    let _v3937 = v3941 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v3942 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v3943 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v3932 v3942 
                                                                                                                                                                                    let _v3937 = v3943 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v3944 : std_path_PathBuf = v3932 |> std_path_PathBuf 
                                                                                                                                                                                    let _v3937 = v3944 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v3947 : std_path_PathBuf = v3932 |> std_path_PathBuf 
                                                                                                                                                                                    let _v3937 = v3947 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v3950 : std_path_PathBuf = v3932 |> std_path_PathBuf 
                                                                                                                                                                                    let _v3937 = v3950 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v3953 : std_path_PathBuf = _v3937 
                                                                                                                                                                                    let v3958 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v3959 : string = "Ok($0)"
                                                                                                                                                                                    let v3960 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3953 v3959 
                                                                                                                                                                                    let _v3958 = v3960 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v3961 : string = "Ok($0)"
                                                                                                                                                                                    let v3962 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3953 v3961 
                                                                                                                                                                                    let _v3958 = v3962 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v3963 : string = "Ok($0)"
                                                                                                                                                                                    let v3964 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3953 v3963 
                                                                                                                                                                                    let _v3958 = v3964 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v3965 : Result<std_path_PathBuf, std_io_Error> = v3953 |> Ok
                                                                                                                                                                                    let _v3958 = v3965 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v3966 : Result<std_path_PathBuf, std_io_Error> = v3953 |> Ok
                                                                                                                                                                                    let _v3958 = v3966 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v3967 : Result<std_path_PathBuf, std_io_Error> = v3953 |> Ok
                                                                                                                                                                                    let _v3958 = v3967 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v3968 : Result<std_path_PathBuf, std_io_Error> = _v3958 
                                                                                                                                                                                    v3968
                                                                                                                                                                            else
                                                                                                                                                                                let v4001 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3490} / path': {v3455} / name: {v3491}"
                                                                                                                                                                                let v4002 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v4003 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v4004 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4001 v4003 
                                                                                                                                                                                let _v4002 = v4004 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v4005 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v4006 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4001 v4005 
                                                                                                                                                                                let _v4002 = v4006 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v4007 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v4008 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4001 v4007 
                                                                                                                                                                                let _v4002 = v4008 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v4009 : std_io_Error = v4001 
                                                                                                                                                                                let _v4002 = v4009 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v4010 : std_io_Error = v4001 
                                                                                                                                                                                let _v4002 = v4010 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v4011 : std_io_Error = v4001 
                                                                                                                                                                                let _v4002 = v4011 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v4012 : std_io_Error = _v4002 
                                                                                                                                                                                let v4015 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v4016 : string = "Err($0)"
                                                                                                                                                                                let v4017 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4012 v4016 
                                                                                                                                                                                let _v4015 = v4017 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v4018 : string = "Err($0)"
                                                                                                                                                                                let v4019 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4012 v4018 
                                                                                                                                                                                let _v4015 = v4019 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v4020 : string = "Err($0)"
                                                                                                                                                                                let v4021 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4012 v4020 
                                                                                                                                                                                let _v4015 = v4021 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v4022 : Result<std_path_PathBuf, std_io_Error> = v4012 |> Error
                                                                                                                                                                                let _v4015 = v4022 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v4023 : Result<std_path_PathBuf, std_io_Error> = v4012 |> Error
                                                                                                                                                                                let _v4015 = v4023 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v4024 : Result<std_path_PathBuf, std_io_Error> = v4012 |> Error
                                                                                                                                                                                let _v4015 = v4024 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v4025 : Result<std_path_PathBuf, std_io_Error> = _v4015 
                                                                                                                                                                                v4025
                                                                                                                                                                        | _ ->
                                                                                                                                                                            let v4029 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3490} / path': {v3455} / name: {v3491}"
                                                                                                                                                                            let v4030 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v4031 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v4032 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4029 v4031 
                                                                                                                                                                            let _v4030 = v4032 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v4033 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v4034 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4029 v4033 
                                                                                                                                                                            let _v4030 = v4034 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v4035 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v4036 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4029 v4035 
                                                                                                                                                                            let _v4030 = v4036 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v4037 : std_io_Error = v4029 
                                                                                                                                                                            let _v4030 = v4037 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v4038 : std_io_Error = v4029 
                                                                                                                                                                            let _v4030 = v4038 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v4039 : std_io_Error = v4029 
                                                                                                                                                                            let _v4030 = v4039 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v4040 : std_io_Error = _v4030 
                                                                                                                                                                            let v4043 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v4044 : string = "Err($0)"
                                                                                                                                                                            let v4045 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4040 v4044 
                                                                                                                                                                            let _v4043 = v4045 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v4046 : string = "Err($0)"
                                                                                                                                                                            let v4047 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4040 v4046 
                                                                                                                                                                            let _v4043 = v4047 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v4048 : string = "Err($0)"
                                                                                                                                                                            let v4049 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4040 v4048 
                                                                                                                                                                            let _v4043 = v4049 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v4050 : Result<std_path_PathBuf, std_io_Error> = v4040 |> Error
                                                                                                                                                                            let _v4043 = v4050 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v4051 : Result<std_path_PathBuf, std_io_Error> = v4040 |> Error
                                                                                                                                                                            let _v4043 = v4051 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v4052 : Result<std_path_PathBuf, std_io_Error> = v4040 |> Error
                                                                                                                                                                            let _v4043 = v4052 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v4053 : Result<std_path_PathBuf, std_io_Error> = _v4043 
                                                                                                                                                                            v4053
                                                                                                                                                                    | US13_0(v3476) -> (* Ok *)
                                                                                                                                                                        let v3477 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v3478 : string = "Ok($0)"
                                                                                                                                                                        let v3479 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3476 v3478 
                                                                                                                                                                        let _v3477 = v3479 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v3480 : string = "Ok($0)"
                                                                                                                                                                        let v3481 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3476 v3480 
                                                                                                                                                                        let _v3477 = v3481 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v3482 : string = "Ok($0)"
                                                                                                                                                                        let v3483 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3476 v3482 
                                                                                                                                                                        let _v3477 = v3483 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v3484 : Result<std_path_PathBuf, std_io_Error> = v3476 |> Ok
                                                                                                                                                                        let _v3477 = v3484 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v3485 : Result<std_path_PathBuf, std_io_Error> = v3476 |> Ok
                                                                                                                                                                        let _v3477 = v3485 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v3486 : Result<std_path_PathBuf, std_io_Error> = v3476 |> Ok
                                                                                                                                                                        let _v3477 = v3486 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v3487 : Result<std_path_PathBuf, std_io_Error> = _v3477 
                                                                                                                                                                        v3487
                                                                                                                                                                let v4059 : (std_io_Error -> string) = method76()
                                                                                                                                                                let v4060 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4061 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v4062 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4058, v4059) v4061 
                                                                                                                                                                let _v4060 = v4062 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4063 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v4064 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4058, v4059) v4063 
                                                                                                                                                                let _v4060 = v4064 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4065 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v4066 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4058, v4059) v4065 
                                                                                                                                                                let _v4060 = v4066 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4067 : Result<std_path_PathBuf, string> = match v4058 with Ok x -> Ok x | Error x -> Error (v4059 x)
                                                                                                                                                                let _v4060 = v4067 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4068 : Result<std_path_PathBuf, string> = match v4058 with Ok x -> Ok x | Error x -> Error (v4059 x)
                                                                                                                                                                let _v4060 = v4068 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4069 : Result<std_path_PathBuf, string> = match v4058 with Ok x -> Ok x | Error x -> Error (v4059 x)
                                                                                                                                                                let _v4060 = v4069 
                                                                                                                                                                #endif
                                                                                                                                                                let v4070 : Result<std_path_PathBuf, string> = _v4060 
                                                                                                                                                                let v4073 : US13 = match v4070 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                                                match v4073 with
                                                                                                                                                                | US13_1(v4176) -> (* Error *)
                                                                                                                                                                    let v4177 : string = $"file_system.read_link / error': {v4176} / error: {v3435} / name: {v3436}"
                                                                                                                                                                    let v4178 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v4179 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v4180 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4177 v4179 
                                                                                                                                                                    let _v4178 = v4180 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v4181 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v4182 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4177 v4181 
                                                                                                                                                                    let _v4178 = v4182 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v4183 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v4184 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4177 v4183 
                                                                                                                                                                    let _v4178 = v4184 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v4185 : std_io_Error = v4177 
                                                                                                                                                                    let _v4178 = v4185 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v4186 : std_io_Error = v4177 
                                                                                                                                                                    let _v4178 = v4186 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v4187 : std_io_Error = v4177 
                                                                                                                                                                    let _v4178 = v4187 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v4188 : std_io_Error = _v4178 
                                                                                                                                                                    let v4191 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v4192 : string = "Err($0)"
                                                                                                                                                                    let v4193 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4188 v4192 
                                                                                                                                                                    let _v4191 = v4193 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v4194 : string = "Err($0)"
                                                                                                                                                                    let v4195 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4188 v4194 
                                                                                                                                                                    let _v4191 = v4195 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v4196 : string = "Err($0)"
                                                                                                                                                                    let v4197 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4188 v4196 
                                                                                                                                                                    let _v4191 = v4197 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v4198 : Result<std_path_PathBuf, std_io_Error> = v4188 |> Error
                                                                                                                                                                    let _v4191 = v4198 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v4199 : Result<std_path_PathBuf, std_io_Error> = v4188 |> Error
                                                                                                                                                                    let _v4191 = v4199 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v4200 : Result<std_path_PathBuf, std_io_Error> = v4188 |> Error
                                                                                                                                                                    let _v4191 = v4200 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v4201 : Result<std_path_PathBuf, std_io_Error> = _v4191 
                                                                                                                                                                    v4201
                                                                                                                                                                | US13_0(v4074) -> (* Ok *)
                                                                                                                                                                    let v4075 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v4076 : string = "$0.display()"
                                                                                                                                                                    let v4077 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4074 v4076 
                                                                                                                                                                    let _v4075 = v4077 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v4078 : string = "$0.display()"
                                                                                                                                                                    let v4079 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4074 v4078 
                                                                                                                                                                    let _v4075 = v4079 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v4080 : string = "$0.display()"
                                                                                                                                                                    let v4081 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4074 v4080 
                                                                                                                                                                    let _v4075 = v4081 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v4082 : std_path_Display = v4074 |> unbox<std_path_Display>
                                                                                                                                                                    let _v4075 = v4082 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v4085 : std_path_Display = v4074 |> unbox<std_path_Display>
                                                                                                                                                                    let _v4075 = v4085 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v4088 : std_path_Display = v4074 |> unbox<std_path_Display>
                                                                                                                                                                    let _v4075 = v4088 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v4091 : std_path_Display = _v4075 
                                                                                                                                                                    let v4096 : string = v4091 |> string 
                                                                                                                                                                    let v4099 : string = method56(v4096, v3436)
                                                                                                                                                                    let v4100 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v4101 : string = "&*$0"
                                                                                                                                                                    let v4102 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4099 v4101 
                                                                                                                                                                    let _v4100 = v4102 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v4103 : string = "&*$0"
                                                                                                                                                                    let v4104 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4099 v4103 
                                                                                                                                                                    let _v4100 = v4104 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v4105 : string = "&*$0"
                                                                                                                                                                    let v4106 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4099 v4105 
                                                                                                                                                                    let _v4100 = v4106 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v4107 : Ref<Str> = v4099 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v4100 = v4107 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v4110 : Ref<Str> = v4099 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v4100 = v4110 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v4113 : Ref<Str> = v4099 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v4100 = v4113 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v4116 : Ref<Str> = _v4100 
                                                                                                                                                                    let v4121 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v4122 : string = "String::from($0)"
                                                                                                                                                                    let v4123 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4116 v4122 
                                                                                                                                                                    let _v4121 = v4123 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v4124 : string = "String::from($0)"
                                                                                                                                                                    let v4125 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4116 v4124 
                                                                                                                                                                    let _v4121 = v4125 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v4126 : string = "String::from($0)"
                                                                                                                                                                    let v4127 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4116 v4126 
                                                                                                                                                                    let _v4121 = v4127 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v4128 : std_string_String = v4116 |> unbox<std_string_String>
                                                                                                                                                                    let _v4121 = v4128 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v4131 : std_string_String = v4116 |> unbox<std_string_String>
                                                                                                                                                                    let _v4121 = v4131 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v4134 : std_string_String = v4116 |> unbox<std_string_String>
                                                                                                                                                                    let _v4121 = v4134 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v4137 : std_string_String = _v4121 
                                                                                                                                                                    let v4142 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v4143 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v4144 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4137 v4143 
                                                                                                                                                                    let _v4142 = v4144 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v4145 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v4146 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4137 v4145 
                                                                                                                                                                    let _v4142 = v4146 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v4147 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v4148 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4137 v4147 
                                                                                                                                                                    let _v4142 = v4148 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v4149 : std_path_PathBuf = v4137 |> std_path_PathBuf 
                                                                                                                                                                    let _v4142 = v4149 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v4152 : std_path_PathBuf = v4137 |> std_path_PathBuf 
                                                                                                                                                                    let _v4142 = v4152 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v4155 : std_path_PathBuf = v4137 |> std_path_PathBuf 
                                                                                                                                                                    let _v4142 = v4155 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v4158 : std_path_PathBuf = _v4142 
                                                                                                                                                                    let v4163 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v4164 : string = "Ok($0)"
                                                                                                                                                                    let v4165 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4158 v4164 
                                                                                                                                                                    let _v4163 = v4165 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v4166 : string = "Ok($0)"
                                                                                                                                                                    let v4167 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4158 v4166 
                                                                                                                                                                    let _v4163 = v4167 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v4168 : string = "Ok($0)"
                                                                                                                                                                    let v4169 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4158 v4168 
                                                                                                                                                                    let _v4163 = v4169 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v4170 : Result<std_path_PathBuf, std_io_Error> = v4158 |> Ok
                                                                                                                                                                    let _v4163 = v4170 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v4171 : Result<std_path_PathBuf, std_io_Error> = v4158 |> Ok
                                                                                                                                                                    let _v4163 = v4171 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v4172 : Result<std_path_PathBuf, std_io_Error> = v4158 |> Ok
                                                                                                                                                                    let _v4163 = v4172 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v4173 : Result<std_path_PathBuf, std_io_Error> = _v4163 
                                                                                                                                                                    v4173
                                                                                                                                                            else
                                                                                                                                                                let v4206 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3435} / path': {v3400} / name: {v3436}"
                                                                                                                                                                let v4207 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4208 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v4209 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4206 v4208 
                                                                                                                                                                let _v4207 = v4209 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4210 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v4211 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4206 v4210 
                                                                                                                                                                let _v4207 = v4211 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4212 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v4213 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4206 v4212 
                                                                                                                                                                let _v4207 = v4213 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4214 : std_io_Error = v4206 
                                                                                                                                                                let _v4207 = v4214 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4215 : std_io_Error = v4206 
                                                                                                                                                                let _v4207 = v4215 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4216 : std_io_Error = v4206 
                                                                                                                                                                let _v4207 = v4216 
                                                                                                                                                                #endif
                                                                                                                                                                let v4217 : std_io_Error = _v4207 
                                                                                                                                                                let v4220 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v4221 : string = "Err($0)"
                                                                                                                                                                let v4222 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4217 v4221 
                                                                                                                                                                let _v4220 = v4222 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v4223 : string = "Err($0)"
                                                                                                                                                                let v4224 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4217 v4223 
                                                                                                                                                                let _v4220 = v4224 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v4225 : string = "Err($0)"
                                                                                                                                                                let v4226 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4217 v4225 
                                                                                                                                                                let _v4220 = v4226 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v4227 : Result<std_path_PathBuf, std_io_Error> = v4217 |> Error
                                                                                                                                                                let _v4220 = v4227 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v4228 : Result<std_path_PathBuf, std_io_Error> = v4217 |> Error
                                                                                                                                                                let _v4220 = v4228 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v4229 : Result<std_path_PathBuf, std_io_Error> = v4217 |> Error
                                                                                                                                                                let _v4220 = v4229 
                                                                                                                                                                #endif
                                                                                                                                                                let v4230 : Result<std_path_PathBuf, std_io_Error> = _v4220 
                                                                                                                                                                v4230
                                                                                                                                                        | _ ->
                                                                                                                                                            let v4234 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3435} / path': {v3400} / name: {v3436}"
                                                                                                                                                            let v4235 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v4236 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v4237 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4234 v4236 
                                                                                                                                                            let _v4235 = v4237 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v4238 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v4239 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4234 v4238 
                                                                                                                                                            let _v4235 = v4239 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v4240 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v4241 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4234 v4240 
                                                                                                                                                            let _v4235 = v4241 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v4242 : std_io_Error = v4234 
                                                                                                                                                            let _v4235 = v4242 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v4243 : std_io_Error = v4234 
                                                                                                                                                            let _v4235 = v4243 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v4244 : std_io_Error = v4234 
                                                                                                                                                            let _v4235 = v4244 
                                                                                                                                                            #endif
                                                                                                                                                            let v4245 : std_io_Error = _v4235 
                                                                                                                                                            let v4248 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v4249 : string = "Err($0)"
                                                                                                                                                            let v4250 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4245 v4249 
                                                                                                                                                            let _v4248 = v4250 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v4251 : string = "Err($0)"
                                                                                                                                                            let v4252 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4245 v4251 
                                                                                                                                                            let _v4248 = v4252 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v4253 : string = "Err($0)"
                                                                                                                                                            let v4254 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4245 v4253 
                                                                                                                                                            let _v4248 = v4254 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v4255 : Result<std_path_PathBuf, std_io_Error> = v4245 |> Error
                                                                                                                                                            let _v4248 = v4255 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v4256 : Result<std_path_PathBuf, std_io_Error> = v4245 |> Error
                                                                                                                                                            let _v4248 = v4256 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v4257 : Result<std_path_PathBuf, std_io_Error> = v4245 |> Error
                                                                                                                                                            let _v4248 = v4257 
                                                                                                                                                            #endif
                                                                                                                                                            let v4258 : Result<std_path_PathBuf, std_io_Error> = _v4248 
                                                                                                                                                            v4258
                                                                                                                                                    | US13_0(v3421) -> (* Ok *)
                                                                                                                                                        let v3422 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v3423 : string = "Ok($0)"
                                                                                                                                                        let v3424 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3421 v3423 
                                                                                                                                                        let _v3422 = v3424 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v3425 : string = "Ok($0)"
                                                                                                                                                        let v3426 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3421 v3425 
                                                                                                                                                        let _v3422 = v3426 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v3427 : string = "Ok($0)"
                                                                                                                                                        let v3428 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3421 v3427 
                                                                                                                                                        let _v3422 = v3428 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v3429 : Result<std_path_PathBuf, std_io_Error> = v3421 |> Ok
                                                                                                                                                        let _v3422 = v3429 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v3430 : Result<std_path_PathBuf, std_io_Error> = v3421 |> Ok
                                                                                                                                                        let _v3422 = v3430 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v3431 : Result<std_path_PathBuf, std_io_Error> = v3421 |> Ok
                                                                                                                                                        let _v3422 = v3431 
                                                                                                                                                        #endif
                                                                                                                                                        let v3432 : Result<std_path_PathBuf, std_io_Error> = _v3422 
                                                                                                                                                        v3432
                                                                                                                                                let v4264 : (std_io_Error -> string) = method76()
                                                                                                                                                let v4265 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4266 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v4267 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4263, v4264) v4266 
                                                                                                                                                let _v4265 = v4267 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4268 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v4269 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4263, v4264) v4268 
                                                                                                                                                let _v4265 = v4269 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4270 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v4271 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4263, v4264) v4270 
                                                                                                                                                let _v4265 = v4271 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4272 : Result<std_path_PathBuf, string> = match v4263 with Ok x -> Ok x | Error x -> Error (v4264 x)
                                                                                                                                                let _v4265 = v4272 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4273 : Result<std_path_PathBuf, string> = match v4263 with Ok x -> Ok x | Error x -> Error (v4264 x)
                                                                                                                                                let _v4265 = v4273 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4274 : Result<std_path_PathBuf, string> = match v4263 with Ok x -> Ok x | Error x -> Error (v4264 x)
                                                                                                                                                let _v4265 = v4274 
                                                                                                                                                #endif
                                                                                                                                                let v4275 : Result<std_path_PathBuf, string> = _v4265 
                                                                                                                                                let v4278 : US13 = match v4275 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                                match v4278 with
                                                                                                                                                | US13_1(v4381) -> (* Error *)
                                                                                                                                                    let v4382 : string = $"file_system.read_link / error': {v4381} / error: {v3380} / name: {v3381}"
                                                                                                                                                    let v4383 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v4384 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v4385 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4382 v4384 
                                                                                                                                                    let _v4383 = v4385 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v4386 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v4387 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4382 v4386 
                                                                                                                                                    let _v4383 = v4387 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v4388 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v4389 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4382 v4388 
                                                                                                                                                    let _v4383 = v4389 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v4390 : std_io_Error = v4382 
                                                                                                                                                    let _v4383 = v4390 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v4391 : std_io_Error = v4382 
                                                                                                                                                    let _v4383 = v4391 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v4392 : std_io_Error = v4382 
                                                                                                                                                    let _v4383 = v4392 
                                                                                                                                                    #endif
                                                                                                                                                    let v4393 : std_io_Error = _v4383 
                                                                                                                                                    let v4396 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v4397 : string = "Err($0)"
                                                                                                                                                    let v4398 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4393 v4397 
                                                                                                                                                    let _v4396 = v4398 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v4399 : string = "Err($0)"
                                                                                                                                                    let v4400 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4393 v4399 
                                                                                                                                                    let _v4396 = v4400 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v4401 : string = "Err($0)"
                                                                                                                                                    let v4402 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4393 v4401 
                                                                                                                                                    let _v4396 = v4402 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v4403 : Result<std_path_PathBuf, std_io_Error> = v4393 |> Error
                                                                                                                                                    let _v4396 = v4403 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v4404 : Result<std_path_PathBuf, std_io_Error> = v4393 |> Error
                                                                                                                                                    let _v4396 = v4404 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v4405 : Result<std_path_PathBuf, std_io_Error> = v4393 |> Error
                                                                                                                                                    let _v4396 = v4405 
                                                                                                                                                    #endif
                                                                                                                                                    let v4406 : Result<std_path_PathBuf, std_io_Error> = _v4396 
                                                                                                                                                    v4406
                                                                                                                                                | US13_0(v4279) -> (* Ok *)
                                                                                                                                                    let v4280 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v4281 : string = "$0.display()"
                                                                                                                                                    let v4282 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4279 v4281 
                                                                                                                                                    let _v4280 = v4282 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v4283 : string = "$0.display()"
                                                                                                                                                    let v4284 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4279 v4283 
                                                                                                                                                    let _v4280 = v4284 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v4285 : string = "$0.display()"
                                                                                                                                                    let v4286 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4279 v4285 
                                                                                                                                                    let _v4280 = v4286 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v4287 : std_path_Display = v4279 |> unbox<std_path_Display>
                                                                                                                                                    let _v4280 = v4287 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v4290 : std_path_Display = v4279 |> unbox<std_path_Display>
                                                                                                                                                    let _v4280 = v4290 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v4293 : std_path_Display = v4279 |> unbox<std_path_Display>
                                                                                                                                                    let _v4280 = v4293 
                                                                                                                                                    #endif
                                                                                                                                                    let v4296 : std_path_Display = _v4280 
                                                                                                                                                    let v4301 : string = v4296 |> string 
                                                                                                                                                    let v4304 : string = method56(v4301, v3381)
                                                                                                                                                    let v4305 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v4306 : string = "&*$0"
                                                                                                                                                    let v4307 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4304 v4306 
                                                                                                                                                    let _v4305 = v4307 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v4308 : string = "&*$0"
                                                                                                                                                    let v4309 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4304 v4308 
                                                                                                                                                    let _v4305 = v4309 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v4310 : string = "&*$0"
                                                                                                                                                    let v4311 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4304 v4310 
                                                                                                                                                    let _v4305 = v4311 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v4312 : Ref<Str> = v4304 |> unbox<Ref<Str>>
                                                                                                                                                    let _v4305 = v4312 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v4315 : Ref<Str> = v4304 |> unbox<Ref<Str>>
                                                                                                                                                    let _v4305 = v4315 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v4318 : Ref<Str> = v4304 |> unbox<Ref<Str>>
                                                                                                                                                    let _v4305 = v4318 
                                                                                                                                                    #endif
                                                                                                                                                    let v4321 : Ref<Str> = _v4305 
                                                                                                                                                    let v4326 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v4327 : string = "String::from($0)"
                                                                                                                                                    let v4328 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4321 v4327 
                                                                                                                                                    let _v4326 = v4328 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v4329 : string = "String::from($0)"
                                                                                                                                                    let v4330 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4321 v4329 
                                                                                                                                                    let _v4326 = v4330 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v4331 : string = "String::from($0)"
                                                                                                                                                    let v4332 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4321 v4331 
                                                                                                                                                    let _v4326 = v4332 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v4333 : std_string_String = v4321 |> unbox<std_string_String>
                                                                                                                                                    let _v4326 = v4333 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v4336 : std_string_String = v4321 |> unbox<std_string_String>
                                                                                                                                                    let _v4326 = v4336 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v4339 : std_string_String = v4321 |> unbox<std_string_String>
                                                                                                                                                    let _v4326 = v4339 
                                                                                                                                                    #endif
                                                                                                                                                    let v4342 : std_string_String = _v4326 
                                                                                                                                                    let v4347 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v4348 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v4349 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4342 v4348 
                                                                                                                                                    let _v4347 = v4349 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v4350 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v4351 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4342 v4350 
                                                                                                                                                    let _v4347 = v4351 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v4352 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v4353 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4342 v4352 
                                                                                                                                                    let _v4347 = v4353 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v4354 : std_path_PathBuf = v4342 |> std_path_PathBuf 
                                                                                                                                                    let _v4347 = v4354 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v4357 : std_path_PathBuf = v4342 |> std_path_PathBuf 
                                                                                                                                                    let _v4347 = v4357 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v4360 : std_path_PathBuf = v4342 |> std_path_PathBuf 
                                                                                                                                                    let _v4347 = v4360 
                                                                                                                                                    #endif
                                                                                                                                                    let v4363 : std_path_PathBuf = _v4347 
                                                                                                                                                    let v4368 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v4369 : string = "Ok($0)"
                                                                                                                                                    let v4370 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4363 v4369 
                                                                                                                                                    let _v4368 = v4370 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v4371 : string = "Ok($0)"
                                                                                                                                                    let v4372 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4363 v4371 
                                                                                                                                                    let _v4368 = v4372 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v4373 : string = "Ok($0)"
                                                                                                                                                    let v4374 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4363 v4373 
                                                                                                                                                    let _v4368 = v4374 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v4375 : Result<std_path_PathBuf, std_io_Error> = v4363 |> Ok
                                                                                                                                                    let _v4368 = v4375 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v4376 : Result<std_path_PathBuf, std_io_Error> = v4363 |> Ok
                                                                                                                                                    let _v4368 = v4376 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v4377 : Result<std_path_PathBuf, std_io_Error> = v4363 |> Ok
                                                                                                                                                    let _v4368 = v4377 
                                                                                                                                                    #endif
                                                                                                                                                    let v4378 : Result<std_path_PathBuf, std_io_Error> = _v4368 
                                                                                                                                                    v4378
                                                                                                                                            else
                                                                                                                                                let v4411 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3380} / path': {v3345} / name: {v3381}"
                                                                                                                                                let v4412 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4413 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v4414 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4411 v4413 
                                                                                                                                                let _v4412 = v4414 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4415 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v4416 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4411 v4415 
                                                                                                                                                let _v4412 = v4416 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4417 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v4418 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4411 v4417 
                                                                                                                                                let _v4412 = v4418 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4419 : std_io_Error = v4411 
                                                                                                                                                let _v4412 = v4419 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4420 : std_io_Error = v4411 
                                                                                                                                                let _v4412 = v4420 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4421 : std_io_Error = v4411 
                                                                                                                                                let _v4412 = v4421 
                                                                                                                                                #endif
                                                                                                                                                let v4422 : std_io_Error = _v4412 
                                                                                                                                                let v4425 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v4426 : string = "Err($0)"
                                                                                                                                                let v4427 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4422 v4426 
                                                                                                                                                let _v4425 = v4427 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v4428 : string = "Err($0)"
                                                                                                                                                let v4429 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4422 v4428 
                                                                                                                                                let _v4425 = v4429 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v4430 : string = "Err($0)"
                                                                                                                                                let v4431 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4422 v4430 
                                                                                                                                                let _v4425 = v4431 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v4432 : Result<std_path_PathBuf, std_io_Error> = v4422 |> Error
                                                                                                                                                let _v4425 = v4432 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v4433 : Result<std_path_PathBuf, std_io_Error> = v4422 |> Error
                                                                                                                                                let _v4425 = v4433 
                                                                                                                                                #endif
#else
                                                                                                                                                let v4434 : Result<std_path_PathBuf, std_io_Error> = v4422 |> Error
                                                                                                                                                let _v4425 = v4434 
                                                                                                                                                #endif
                                                                                                                                                let v4435 : Result<std_path_PathBuf, std_io_Error> = _v4425 
                                                                                                                                                v4435
                                                                                                                                        | _ ->
                                                                                                                                            let v4439 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3380} / path': {v3345} / name: {v3381}"
                                                                                                                                            let v4440 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v4441 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v4442 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4439 v4441 
                                                                                                                                            let _v4440 = v4442 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v4443 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v4444 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4439 v4443 
                                                                                                                                            let _v4440 = v4444 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v4445 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v4446 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4439 v4445 
                                                                                                                                            let _v4440 = v4446 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v4447 : std_io_Error = v4439 
                                                                                                                                            let _v4440 = v4447 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v4448 : std_io_Error = v4439 
                                                                                                                                            let _v4440 = v4448 
                                                                                                                                            #endif
#else
                                                                                                                                            let v4449 : std_io_Error = v4439 
                                                                                                                                            let _v4440 = v4449 
                                                                                                                                            #endif
                                                                                                                                            let v4450 : std_io_Error = _v4440 
                                                                                                                                            let v4453 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v4454 : string = "Err($0)"
                                                                                                                                            let v4455 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4450 v4454 
                                                                                                                                            let _v4453 = v4455 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v4456 : string = "Err($0)"
                                                                                                                                            let v4457 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4450 v4456 
                                                                                                                                            let _v4453 = v4457 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v4458 : string = "Err($0)"
                                                                                                                                            let v4459 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4450 v4458 
                                                                                                                                            let _v4453 = v4459 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v4460 : Result<std_path_PathBuf, std_io_Error> = v4450 |> Error
                                                                                                                                            let _v4453 = v4460 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v4461 : Result<std_path_PathBuf, std_io_Error> = v4450 |> Error
                                                                                                                                            let _v4453 = v4461 
                                                                                                                                            #endif
#else
                                                                                                                                            let v4462 : Result<std_path_PathBuf, std_io_Error> = v4450 |> Error
                                                                                                                                            let _v4453 = v4462 
                                                                                                                                            #endif
                                                                                                                                            let v4463 : Result<std_path_PathBuf, std_io_Error> = _v4453 
                                                                                                                                            v4463
                                                                                                                                    | US13_0(v3366) -> (* Ok *)
                                                                                                                                        let v3367 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v3368 : string = "Ok($0)"
                                                                                                                                        let v3369 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3366 v3368 
                                                                                                                                        let _v3367 = v3369 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v3370 : string = "Ok($0)"
                                                                                                                                        let v3371 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3366 v3370 
                                                                                                                                        let _v3367 = v3371 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v3372 : string = "Ok($0)"
                                                                                                                                        let v3373 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3366 v3372 
                                                                                                                                        let _v3367 = v3373 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v3374 : Result<std_path_PathBuf, std_io_Error> = v3366 |> Ok
                                                                                                                                        let _v3367 = v3374 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v3375 : Result<std_path_PathBuf, std_io_Error> = v3366 |> Ok
                                                                                                                                        let _v3367 = v3375 
                                                                                                                                        #endif
#else
                                                                                                                                        let v3376 : Result<std_path_PathBuf, std_io_Error> = v3366 |> Ok
                                                                                                                                        let _v3367 = v3376 
                                                                                                                                        #endif
                                                                                                                                        let v3377 : Result<std_path_PathBuf, std_io_Error> = _v3367 
                                                                                                                                        v3377
                                                                                                                                let v4469 : (std_io_Error -> string) = method76()
                                                                                                                                let v4470 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4471 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v4472 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4468, v4469) v4471 
                                                                                                                                let _v4470 = v4472 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4473 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v4474 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4468, v4469) v4473 
                                                                                                                                let _v4470 = v4474 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4475 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v4476 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4468, v4469) v4475 
                                                                                                                                let _v4470 = v4476 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4477 : Result<std_path_PathBuf, string> = match v4468 with Ok x -> Ok x | Error x -> Error (v4469 x)
                                                                                                                                let _v4470 = v4477 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4478 : Result<std_path_PathBuf, string> = match v4468 with Ok x -> Ok x | Error x -> Error (v4469 x)
                                                                                                                                let _v4470 = v4478 
                                                                                                                                #endif
#else
                                                                                                                                let v4479 : Result<std_path_PathBuf, string> = match v4468 with Ok x -> Ok x | Error x -> Error (v4469 x)
                                                                                                                                let _v4470 = v4479 
                                                                                                                                #endif
                                                                                                                                let v4480 : Result<std_path_PathBuf, string> = _v4470 
                                                                                                                                let v4483 : US13 = match v4480 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                                match v4483 with
                                                                                                                                | US13_1(v4586) -> (* Error *)
                                                                                                                                    let v4587 : string = $"file_system.read_link / error': {v4586} / error: {v3325} / name: {v3326}"
                                                                                                                                    let v4588 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v4589 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v4590 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4587 v4589 
                                                                                                                                    let _v4588 = v4590 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v4591 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v4592 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4587 v4591 
                                                                                                                                    let _v4588 = v4592 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v4593 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v4594 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4587 v4593 
                                                                                                                                    let _v4588 = v4594 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v4595 : std_io_Error = v4587 
                                                                                                                                    let _v4588 = v4595 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v4596 : std_io_Error = v4587 
                                                                                                                                    let _v4588 = v4596 
                                                                                                                                    #endif
#else
                                                                                                                                    let v4597 : std_io_Error = v4587 
                                                                                                                                    let _v4588 = v4597 
                                                                                                                                    #endif
                                                                                                                                    let v4598 : std_io_Error = _v4588 
                                                                                                                                    let v4601 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v4602 : string = "Err($0)"
                                                                                                                                    let v4603 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4598 v4602 
                                                                                                                                    let _v4601 = v4603 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v4604 : string = "Err($0)"
                                                                                                                                    let v4605 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4598 v4604 
                                                                                                                                    let _v4601 = v4605 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v4606 : string = "Err($0)"
                                                                                                                                    let v4607 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4598 v4606 
                                                                                                                                    let _v4601 = v4607 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v4608 : Result<std_path_PathBuf, std_io_Error> = v4598 |> Error
                                                                                                                                    let _v4601 = v4608 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v4609 : Result<std_path_PathBuf, std_io_Error> = v4598 |> Error
                                                                                                                                    let _v4601 = v4609 
                                                                                                                                    #endif
#else
                                                                                                                                    let v4610 : Result<std_path_PathBuf, std_io_Error> = v4598 |> Error
                                                                                                                                    let _v4601 = v4610 
                                                                                                                                    #endif
                                                                                                                                    let v4611 : Result<std_path_PathBuf, std_io_Error> = _v4601 
                                                                                                                                    v4611
                                                                                                                                | US13_0(v4484) -> (* Ok *)
                                                                                                                                    let v4485 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v4486 : string = "$0.display()"
                                                                                                                                    let v4487 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4484 v4486 
                                                                                                                                    let _v4485 = v4487 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v4488 : string = "$0.display()"
                                                                                                                                    let v4489 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4484 v4488 
                                                                                                                                    let _v4485 = v4489 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v4490 : string = "$0.display()"
                                                                                                                                    let v4491 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4484 v4490 
                                                                                                                                    let _v4485 = v4491 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v4492 : std_path_Display = v4484 |> unbox<std_path_Display>
                                                                                                                                    let _v4485 = v4492 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v4495 : std_path_Display = v4484 |> unbox<std_path_Display>
                                                                                                                                    let _v4485 = v4495 
                                                                                                                                    #endif
#else
                                                                                                                                    let v4498 : std_path_Display = v4484 |> unbox<std_path_Display>
                                                                                                                                    let _v4485 = v4498 
                                                                                                                                    #endif
                                                                                                                                    let v4501 : std_path_Display = _v4485 
                                                                                                                                    let v4506 : string = v4501 |> string 
                                                                                                                                    let v4509 : string = method56(v4506, v3326)
                                                                                                                                    let v4510 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v4511 : string = "&*$0"
                                                                                                                                    let v4512 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4509 v4511 
                                                                                                                                    let _v4510 = v4512 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v4513 : string = "&*$0"
                                                                                                                                    let v4514 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4509 v4513 
                                                                                                                                    let _v4510 = v4514 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v4515 : string = "&*$0"
                                                                                                                                    let v4516 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4509 v4515 
                                                                                                                                    let _v4510 = v4516 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v4517 : Ref<Str> = v4509 |> unbox<Ref<Str>>
                                                                                                                                    let _v4510 = v4517 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v4520 : Ref<Str> = v4509 |> unbox<Ref<Str>>
                                                                                                                                    let _v4510 = v4520 
                                                                                                                                    #endif
#else
                                                                                                                                    let v4523 : Ref<Str> = v4509 |> unbox<Ref<Str>>
                                                                                                                                    let _v4510 = v4523 
                                                                                                                                    #endif
                                                                                                                                    let v4526 : Ref<Str> = _v4510 
                                                                                                                                    let v4531 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v4532 : string = "String::from($0)"
                                                                                                                                    let v4533 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4526 v4532 
                                                                                                                                    let _v4531 = v4533 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v4534 : string = "String::from($0)"
                                                                                                                                    let v4535 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4526 v4534 
                                                                                                                                    let _v4531 = v4535 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v4536 : string = "String::from($0)"
                                                                                                                                    let v4537 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4526 v4536 
                                                                                                                                    let _v4531 = v4537 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v4538 : std_string_String = v4526 |> unbox<std_string_String>
                                                                                                                                    let _v4531 = v4538 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v4541 : std_string_String = v4526 |> unbox<std_string_String>
                                                                                                                                    let _v4531 = v4541 
                                                                                                                                    #endif
#else
                                                                                                                                    let v4544 : std_string_String = v4526 |> unbox<std_string_String>
                                                                                                                                    let _v4531 = v4544 
                                                                                                                                    #endif
                                                                                                                                    let v4547 : std_string_String = _v4531 
                                                                                                                                    let v4552 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v4553 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v4554 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4547 v4553 
                                                                                                                                    let _v4552 = v4554 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v4555 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v4556 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4547 v4555 
                                                                                                                                    let _v4552 = v4556 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v4557 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v4558 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4547 v4557 
                                                                                                                                    let _v4552 = v4558 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v4559 : std_path_PathBuf = v4547 |> std_path_PathBuf 
                                                                                                                                    let _v4552 = v4559 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v4562 : std_path_PathBuf = v4547 |> std_path_PathBuf 
                                                                                                                                    let _v4552 = v4562 
                                                                                                                                    #endif
#else
                                                                                                                                    let v4565 : std_path_PathBuf = v4547 |> std_path_PathBuf 
                                                                                                                                    let _v4552 = v4565 
                                                                                                                                    #endif
                                                                                                                                    let v4568 : std_path_PathBuf = _v4552 
                                                                                                                                    let v4573 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v4574 : string = "Ok($0)"
                                                                                                                                    let v4575 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4568 v4574 
                                                                                                                                    let _v4573 = v4575 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v4576 : string = "Ok($0)"
                                                                                                                                    let v4577 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4568 v4576 
                                                                                                                                    let _v4573 = v4577 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v4578 : string = "Ok($0)"
                                                                                                                                    let v4579 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4568 v4578 
                                                                                                                                    let _v4573 = v4579 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v4580 : Result<std_path_PathBuf, std_io_Error> = v4568 |> Ok
                                                                                                                                    let _v4573 = v4580 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v4581 : Result<std_path_PathBuf, std_io_Error> = v4568 |> Ok
                                                                                                                                    let _v4573 = v4581 
                                                                                                                                    #endif
#else
                                                                                                                                    let v4582 : Result<std_path_PathBuf, std_io_Error> = v4568 |> Ok
                                                                                                                                    let _v4573 = v4582 
                                                                                                                                    #endif
                                                                                                                                    let v4583 : Result<std_path_PathBuf, std_io_Error> = _v4573 
                                                                                                                                    v4583
                                                                                                                            else
                                                                                                                                let v4616 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3325} / path': {v3290} / name: {v3326}"
                                                                                                                                let v4617 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4618 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v4619 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4616 v4618 
                                                                                                                                let _v4617 = v4619 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4620 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v4621 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4616 v4620 
                                                                                                                                let _v4617 = v4621 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4622 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v4623 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4616 v4622 
                                                                                                                                let _v4617 = v4623 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4624 : std_io_Error = v4616 
                                                                                                                                let _v4617 = v4624 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4625 : std_io_Error = v4616 
                                                                                                                                let _v4617 = v4625 
                                                                                                                                #endif
#else
                                                                                                                                let v4626 : std_io_Error = v4616 
                                                                                                                                let _v4617 = v4626 
                                                                                                                                #endif
                                                                                                                                let v4627 : std_io_Error = _v4617 
                                                                                                                                let v4630 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v4631 : string = "Err($0)"
                                                                                                                                let v4632 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4627 v4631 
                                                                                                                                let _v4630 = v4632 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v4633 : string = "Err($0)"
                                                                                                                                let v4634 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4627 v4633 
                                                                                                                                let _v4630 = v4634 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v4635 : string = "Err($0)"
                                                                                                                                let v4636 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4627 v4635 
                                                                                                                                let _v4630 = v4636 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v4637 : Result<std_path_PathBuf, std_io_Error> = v4627 |> Error
                                                                                                                                let _v4630 = v4637 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v4638 : Result<std_path_PathBuf, std_io_Error> = v4627 |> Error
                                                                                                                                let _v4630 = v4638 
                                                                                                                                #endif
#else
                                                                                                                                let v4639 : Result<std_path_PathBuf, std_io_Error> = v4627 |> Error
                                                                                                                                let _v4630 = v4639 
                                                                                                                                #endif
                                                                                                                                let v4640 : Result<std_path_PathBuf, std_io_Error> = _v4630 
                                                                                                                                v4640
                                                                                                                        | _ ->
                                                                                                                            let v4644 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3325} / path': {v3290} / name: {v3326}"
                                                                                                                            let v4645 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v4646 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v4647 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4644 v4646 
                                                                                                                            let _v4645 = v4647 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v4648 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v4649 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4644 v4648 
                                                                                                                            let _v4645 = v4649 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v4650 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v4651 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4644 v4650 
                                                                                                                            let _v4645 = v4651 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v4652 : std_io_Error = v4644 
                                                                                                                            let _v4645 = v4652 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v4653 : std_io_Error = v4644 
                                                                                                                            let _v4645 = v4653 
                                                                                                                            #endif
#else
                                                                                                                            let v4654 : std_io_Error = v4644 
                                                                                                                            let _v4645 = v4654 
                                                                                                                            #endif
                                                                                                                            let v4655 : std_io_Error = _v4645 
                                                                                                                            let v4658 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v4659 : string = "Err($0)"
                                                                                                                            let v4660 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4655 v4659 
                                                                                                                            let _v4658 = v4660 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v4661 : string = "Err($0)"
                                                                                                                            let v4662 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4655 v4661 
                                                                                                                            let _v4658 = v4662 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v4663 : string = "Err($0)"
                                                                                                                            let v4664 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4655 v4663 
                                                                                                                            let _v4658 = v4664 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v4665 : Result<std_path_PathBuf, std_io_Error> = v4655 |> Error
                                                                                                                            let _v4658 = v4665 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v4666 : Result<std_path_PathBuf, std_io_Error> = v4655 |> Error
                                                                                                                            let _v4658 = v4666 
                                                                                                                            #endif
#else
                                                                                                                            let v4667 : Result<std_path_PathBuf, std_io_Error> = v4655 |> Error
                                                                                                                            let _v4658 = v4667 
                                                                                                                            #endif
                                                                                                                            let v4668 : Result<std_path_PathBuf, std_io_Error> = _v4658 
                                                                                                                            v4668
                                                                                                                    | US13_0(v3311) -> (* Ok *)
                                                                                                                        let v3312 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v3313 : string = "Ok($0)"
                                                                                                                        let v3314 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3311 v3313 
                                                                                                                        let _v3312 = v3314 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v3315 : string = "Ok($0)"
                                                                                                                        let v3316 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3311 v3315 
                                                                                                                        let _v3312 = v3316 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v3317 : string = "Ok($0)"
                                                                                                                        let v3318 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3311 v3317 
                                                                                                                        let _v3312 = v3318 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v3319 : Result<std_path_PathBuf, std_io_Error> = v3311 |> Ok
                                                                                                                        let _v3312 = v3319 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v3320 : Result<std_path_PathBuf, std_io_Error> = v3311 |> Ok
                                                                                                                        let _v3312 = v3320 
                                                                                                                        #endif
#else
                                                                                                                        let v3321 : Result<std_path_PathBuf, std_io_Error> = v3311 |> Ok
                                                                                                                        let _v3312 = v3321 
                                                                                                                        #endif
                                                                                                                        let v3322 : Result<std_path_PathBuf, std_io_Error> = _v3312 
                                                                                                                        v3322
                                                                                                                let v4674 : (std_io_Error -> string) = method76()
                                                                                                                let v4675 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4676 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v4677 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4673, v4674) v4676 
                                                                                                                let _v4675 = v4677 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4678 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v4679 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4673, v4674) v4678 
                                                                                                                let _v4675 = v4679 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4680 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v4681 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4673, v4674) v4680 
                                                                                                                let _v4675 = v4681 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4682 : Result<std_path_PathBuf, string> = match v4673 with Ok x -> Ok x | Error x -> Error (v4674 x)
                                                                                                                let _v4675 = v4682 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4683 : Result<std_path_PathBuf, string> = match v4673 with Ok x -> Ok x | Error x -> Error (v4674 x)
                                                                                                                let _v4675 = v4683 
                                                                                                                #endif
#else
                                                                                                                let v4684 : Result<std_path_PathBuf, string> = match v4673 with Ok x -> Ok x | Error x -> Error (v4674 x)
                                                                                                                let _v4675 = v4684 
                                                                                                                #endif
                                                                                                                let v4685 : Result<std_path_PathBuf, string> = _v4675 
                                                                                                                let v4688 : US13 = match v4685 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                                match v4688 with
                                                                                                                | US13_1(v4791) -> (* Error *)
                                                                                                                    let v4792 : string = $"file_system.read_link / error': {v4791} / error: {v3270} / name: {v3271}"
                                                                                                                    let v4793 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v4794 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v4795 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4792 v4794 
                                                                                                                    let _v4793 = v4795 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v4796 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v4797 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4792 v4796 
                                                                                                                    let _v4793 = v4797 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v4798 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v4799 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4792 v4798 
                                                                                                                    let _v4793 = v4799 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v4800 : std_io_Error = v4792 
                                                                                                                    let _v4793 = v4800 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v4801 : std_io_Error = v4792 
                                                                                                                    let _v4793 = v4801 
                                                                                                                    #endif
#else
                                                                                                                    let v4802 : std_io_Error = v4792 
                                                                                                                    let _v4793 = v4802 
                                                                                                                    #endif
                                                                                                                    let v4803 : std_io_Error = _v4793 
                                                                                                                    let v4806 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v4807 : string = "Err($0)"
                                                                                                                    let v4808 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4803 v4807 
                                                                                                                    let _v4806 = v4808 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v4809 : string = "Err($0)"
                                                                                                                    let v4810 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4803 v4809 
                                                                                                                    let _v4806 = v4810 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v4811 : string = "Err($0)"
                                                                                                                    let v4812 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4803 v4811 
                                                                                                                    let _v4806 = v4812 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v4813 : Result<std_path_PathBuf, std_io_Error> = v4803 |> Error
                                                                                                                    let _v4806 = v4813 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v4814 : Result<std_path_PathBuf, std_io_Error> = v4803 |> Error
                                                                                                                    let _v4806 = v4814 
                                                                                                                    #endif
#else
                                                                                                                    let v4815 : Result<std_path_PathBuf, std_io_Error> = v4803 |> Error
                                                                                                                    let _v4806 = v4815 
                                                                                                                    #endif
                                                                                                                    let v4816 : Result<std_path_PathBuf, std_io_Error> = _v4806 
                                                                                                                    v4816
                                                                                                                | US13_0(v4689) -> (* Ok *)
                                                                                                                    let v4690 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v4691 : string = "$0.display()"
                                                                                                                    let v4692 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4689 v4691 
                                                                                                                    let _v4690 = v4692 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v4693 : string = "$0.display()"
                                                                                                                    let v4694 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4689 v4693 
                                                                                                                    let _v4690 = v4694 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v4695 : string = "$0.display()"
                                                                                                                    let v4696 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4689 v4695 
                                                                                                                    let _v4690 = v4696 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v4697 : std_path_Display = v4689 |> unbox<std_path_Display>
                                                                                                                    let _v4690 = v4697 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v4700 : std_path_Display = v4689 |> unbox<std_path_Display>
                                                                                                                    let _v4690 = v4700 
                                                                                                                    #endif
#else
                                                                                                                    let v4703 : std_path_Display = v4689 |> unbox<std_path_Display>
                                                                                                                    let _v4690 = v4703 
                                                                                                                    #endif
                                                                                                                    let v4706 : std_path_Display = _v4690 
                                                                                                                    let v4711 : string = v4706 |> string 
                                                                                                                    let v4714 : string = method56(v4711, v3271)
                                                                                                                    let v4715 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v4716 : string = "&*$0"
                                                                                                                    let v4717 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4714 v4716 
                                                                                                                    let _v4715 = v4717 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v4718 : string = "&*$0"
                                                                                                                    let v4719 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4714 v4718 
                                                                                                                    let _v4715 = v4719 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v4720 : string = "&*$0"
                                                                                                                    let v4721 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4714 v4720 
                                                                                                                    let _v4715 = v4721 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v4722 : Ref<Str> = v4714 |> unbox<Ref<Str>>
                                                                                                                    let _v4715 = v4722 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v4725 : Ref<Str> = v4714 |> unbox<Ref<Str>>
                                                                                                                    let _v4715 = v4725 
                                                                                                                    #endif
#else
                                                                                                                    let v4728 : Ref<Str> = v4714 |> unbox<Ref<Str>>
                                                                                                                    let _v4715 = v4728 
                                                                                                                    #endif
                                                                                                                    let v4731 : Ref<Str> = _v4715 
                                                                                                                    let v4736 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v4737 : string = "String::from($0)"
                                                                                                                    let v4738 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4731 v4737 
                                                                                                                    let _v4736 = v4738 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v4739 : string = "String::from($0)"
                                                                                                                    let v4740 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4731 v4739 
                                                                                                                    let _v4736 = v4740 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v4741 : string = "String::from($0)"
                                                                                                                    let v4742 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4731 v4741 
                                                                                                                    let _v4736 = v4742 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v4743 : std_string_String = v4731 |> unbox<std_string_String>
                                                                                                                    let _v4736 = v4743 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v4746 : std_string_String = v4731 |> unbox<std_string_String>
                                                                                                                    let _v4736 = v4746 
                                                                                                                    #endif
#else
                                                                                                                    let v4749 : std_string_String = v4731 |> unbox<std_string_String>
                                                                                                                    let _v4736 = v4749 
                                                                                                                    #endif
                                                                                                                    let v4752 : std_string_String = _v4736 
                                                                                                                    let v4757 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v4758 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v4759 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4752 v4758 
                                                                                                                    let _v4757 = v4759 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v4760 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v4761 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4752 v4760 
                                                                                                                    let _v4757 = v4761 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v4762 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v4763 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4752 v4762 
                                                                                                                    let _v4757 = v4763 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v4764 : std_path_PathBuf = v4752 |> std_path_PathBuf 
                                                                                                                    let _v4757 = v4764 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v4767 : std_path_PathBuf = v4752 |> std_path_PathBuf 
                                                                                                                    let _v4757 = v4767 
                                                                                                                    #endif
#else
                                                                                                                    let v4770 : std_path_PathBuf = v4752 |> std_path_PathBuf 
                                                                                                                    let _v4757 = v4770 
                                                                                                                    #endif
                                                                                                                    let v4773 : std_path_PathBuf = _v4757 
                                                                                                                    let v4778 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v4779 : string = "Ok($0)"
                                                                                                                    let v4780 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4773 v4779 
                                                                                                                    let _v4778 = v4780 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v4781 : string = "Ok($0)"
                                                                                                                    let v4782 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4773 v4781 
                                                                                                                    let _v4778 = v4782 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v4783 : string = "Ok($0)"
                                                                                                                    let v4784 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4773 v4783 
                                                                                                                    let _v4778 = v4784 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v4785 : Result<std_path_PathBuf, std_io_Error> = v4773 |> Ok
                                                                                                                    let _v4778 = v4785 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v4786 : Result<std_path_PathBuf, std_io_Error> = v4773 |> Ok
                                                                                                                    let _v4778 = v4786 
                                                                                                                    #endif
#else
                                                                                                                    let v4787 : Result<std_path_PathBuf, std_io_Error> = v4773 |> Ok
                                                                                                                    let _v4778 = v4787 
                                                                                                                    #endif
                                                                                                                    let v4788 : Result<std_path_PathBuf, std_io_Error> = _v4778 
                                                                                                                    v4788
                                                                                                            else
                                                                                                                let v4821 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3270} / path': {v3235} / name: {v3271}"
                                                                                                                let v4822 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4823 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v4824 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4821 v4823 
                                                                                                                let _v4822 = v4824 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4825 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v4826 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4821 v4825 
                                                                                                                let _v4822 = v4826 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4827 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v4828 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4821 v4827 
                                                                                                                let _v4822 = v4828 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4829 : std_io_Error = v4821 
                                                                                                                let _v4822 = v4829 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4830 : std_io_Error = v4821 
                                                                                                                let _v4822 = v4830 
                                                                                                                #endif
#else
                                                                                                                let v4831 : std_io_Error = v4821 
                                                                                                                let _v4822 = v4831 
                                                                                                                #endif
                                                                                                                let v4832 : std_io_Error = _v4822 
                                                                                                                let v4835 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v4836 : string = "Err($0)"
                                                                                                                let v4837 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4832 v4836 
                                                                                                                let _v4835 = v4837 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v4838 : string = "Err($0)"
                                                                                                                let v4839 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4832 v4838 
                                                                                                                let _v4835 = v4839 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v4840 : string = "Err($0)"
                                                                                                                let v4841 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4832 v4840 
                                                                                                                let _v4835 = v4841 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v4842 : Result<std_path_PathBuf, std_io_Error> = v4832 |> Error
                                                                                                                let _v4835 = v4842 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v4843 : Result<std_path_PathBuf, std_io_Error> = v4832 |> Error
                                                                                                                let _v4835 = v4843 
                                                                                                                #endif
#else
                                                                                                                let v4844 : Result<std_path_PathBuf, std_io_Error> = v4832 |> Error
                                                                                                                let _v4835 = v4844 
                                                                                                                #endif
                                                                                                                let v4845 : Result<std_path_PathBuf, std_io_Error> = _v4835 
                                                                                                                v4845
                                                                                                        | _ ->
                                                                                                            let v4849 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3270} / path': {v3235} / name: {v3271}"
                                                                                                            let v4850 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v4851 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v4852 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4849 v4851 
                                                                                                            let _v4850 = v4852 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v4853 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v4854 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4849 v4853 
                                                                                                            let _v4850 = v4854 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v4855 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v4856 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4849 v4855 
                                                                                                            let _v4850 = v4856 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v4857 : std_io_Error = v4849 
                                                                                                            let _v4850 = v4857 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v4858 : std_io_Error = v4849 
                                                                                                            let _v4850 = v4858 
                                                                                                            #endif
#else
                                                                                                            let v4859 : std_io_Error = v4849 
                                                                                                            let _v4850 = v4859 
                                                                                                            #endif
                                                                                                            let v4860 : std_io_Error = _v4850 
                                                                                                            let v4863 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v4864 : string = "Err($0)"
                                                                                                            let v4865 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4860 v4864 
                                                                                                            let _v4863 = v4865 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v4866 : string = "Err($0)"
                                                                                                            let v4867 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4860 v4866 
                                                                                                            let _v4863 = v4867 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v4868 : string = "Err($0)"
                                                                                                            let v4869 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4860 v4868 
                                                                                                            let _v4863 = v4869 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v4870 : Result<std_path_PathBuf, std_io_Error> = v4860 |> Error
                                                                                                            let _v4863 = v4870 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v4871 : Result<std_path_PathBuf, std_io_Error> = v4860 |> Error
                                                                                                            let _v4863 = v4871 
                                                                                                            #endif
#else
                                                                                                            let v4872 : Result<std_path_PathBuf, std_io_Error> = v4860 |> Error
                                                                                                            let _v4863 = v4872 
                                                                                                            #endif
                                                                                                            let v4873 : Result<std_path_PathBuf, std_io_Error> = _v4863 
                                                                                                            v4873
                                                                                                    | US13_0(v3256) -> (* Ok *)
                                                                                                        let v3257 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v3258 : string = "Ok($0)"
                                                                                                        let v3259 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3256 v3258 
                                                                                                        let _v3257 = v3259 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v3260 : string = "Ok($0)"
                                                                                                        let v3261 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3256 v3260 
                                                                                                        let _v3257 = v3261 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v3262 : string = "Ok($0)"
                                                                                                        let v3263 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3256 v3262 
                                                                                                        let _v3257 = v3263 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v3264 : Result<std_path_PathBuf, std_io_Error> = v3256 |> Ok
                                                                                                        let _v3257 = v3264 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v3265 : Result<std_path_PathBuf, std_io_Error> = v3256 |> Ok
                                                                                                        let _v3257 = v3265 
                                                                                                        #endif
#else
                                                                                                        let v3266 : Result<std_path_PathBuf, std_io_Error> = v3256 |> Ok
                                                                                                        let _v3257 = v3266 
                                                                                                        #endif
                                                                                                        let v3267 : Result<std_path_PathBuf, std_io_Error> = _v3257 
                                                                                                        v3267
                                                                                                let v4879 : (std_io_Error -> string) = method76()
                                                                                                let v4880 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v4881 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v4882 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4878, v4879) v4881 
                                                                                                let _v4880 = v4882 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v4883 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v4884 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4878, v4879) v4883 
                                                                                                let _v4880 = v4884 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v4885 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v4886 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v4878, v4879) v4885 
                                                                                                let _v4880 = v4886 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v4887 : Result<std_path_PathBuf, string> = match v4878 with Ok x -> Ok x | Error x -> Error (v4879 x)
                                                                                                let _v4880 = v4887 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v4888 : Result<std_path_PathBuf, string> = match v4878 with Ok x -> Ok x | Error x -> Error (v4879 x)
                                                                                                let _v4880 = v4888 
                                                                                                #endif
#else
                                                                                                let v4889 : Result<std_path_PathBuf, string> = match v4878 with Ok x -> Ok x | Error x -> Error (v4879 x)
                                                                                                let _v4880 = v4889 
                                                                                                #endif
                                                                                                let v4890 : Result<std_path_PathBuf, string> = _v4880 
                                                                                                let v4893 : US13 = match v4890 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                                match v4893 with
                                                                                                | US13_1(v4996) -> (* Error *)
                                                                                                    let v4997 : string = $"file_system.read_link / error': {v4996} / error: {v3215} / name: {v3216}"
                                                                                                    let v4998 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v4999 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v5000 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4997 v4999 
                                                                                                    let _v4998 = v5000 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v5001 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v5002 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4997 v5001 
                                                                                                    let _v4998 = v5002 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v5003 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v5004 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v4997 v5003 
                                                                                                    let _v4998 = v5004 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v5005 : std_io_Error = v4997 
                                                                                                    let _v4998 = v5005 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v5006 : std_io_Error = v4997 
                                                                                                    let _v4998 = v5006 
                                                                                                    #endif
#else
                                                                                                    let v5007 : std_io_Error = v4997 
                                                                                                    let _v4998 = v5007 
                                                                                                    #endif
                                                                                                    let v5008 : std_io_Error = _v4998 
                                                                                                    let v5011 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v5012 : string = "Err($0)"
                                                                                                    let v5013 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5008 v5012 
                                                                                                    let _v5011 = v5013 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v5014 : string = "Err($0)"
                                                                                                    let v5015 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5008 v5014 
                                                                                                    let _v5011 = v5015 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v5016 : string = "Err($0)"
                                                                                                    let v5017 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5008 v5016 
                                                                                                    let _v5011 = v5017 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v5018 : Result<std_path_PathBuf, std_io_Error> = v5008 |> Error
                                                                                                    let _v5011 = v5018 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v5019 : Result<std_path_PathBuf, std_io_Error> = v5008 |> Error
                                                                                                    let _v5011 = v5019 
                                                                                                    #endif
#else
                                                                                                    let v5020 : Result<std_path_PathBuf, std_io_Error> = v5008 |> Error
                                                                                                    let _v5011 = v5020 
                                                                                                    #endif
                                                                                                    let v5021 : Result<std_path_PathBuf, std_io_Error> = _v5011 
                                                                                                    v5021
                                                                                                | US13_0(v4894) -> (* Ok *)
                                                                                                    let v4895 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v4896 : string = "$0.display()"
                                                                                                    let v4897 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4894 v4896 
                                                                                                    let _v4895 = v4897 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v4898 : string = "$0.display()"
                                                                                                    let v4899 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4894 v4898 
                                                                                                    let _v4895 = v4899 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v4900 : string = "$0.display()"
                                                                                                    let v4901 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v4894 v4900 
                                                                                                    let _v4895 = v4901 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v4902 : std_path_Display = v4894 |> unbox<std_path_Display>
                                                                                                    let _v4895 = v4902 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v4905 : std_path_Display = v4894 |> unbox<std_path_Display>
                                                                                                    let _v4895 = v4905 
                                                                                                    #endif
#else
                                                                                                    let v4908 : std_path_Display = v4894 |> unbox<std_path_Display>
                                                                                                    let _v4895 = v4908 
                                                                                                    #endif
                                                                                                    let v4911 : std_path_Display = _v4895 
                                                                                                    let v4916 : string = v4911 |> string 
                                                                                                    let v4919 : string = method56(v4916, v3216)
                                                                                                    let v4920 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v4921 : string = "&*$0"
                                                                                                    let v4922 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4919 v4921 
                                                                                                    let _v4920 = v4922 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v4923 : string = "&*$0"
                                                                                                    let v4924 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4919 v4923 
                                                                                                    let _v4920 = v4924 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v4925 : string = "&*$0"
                                                                                                    let v4926 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v4919 v4925 
                                                                                                    let _v4920 = v4926 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v4927 : Ref<Str> = v4919 |> unbox<Ref<Str>>
                                                                                                    let _v4920 = v4927 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v4930 : Ref<Str> = v4919 |> unbox<Ref<Str>>
                                                                                                    let _v4920 = v4930 
                                                                                                    #endif
#else
                                                                                                    let v4933 : Ref<Str> = v4919 |> unbox<Ref<Str>>
                                                                                                    let _v4920 = v4933 
                                                                                                    #endif
                                                                                                    let v4936 : Ref<Str> = _v4920 
                                                                                                    let v4941 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v4942 : string = "String::from($0)"
                                                                                                    let v4943 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4936 v4942 
                                                                                                    let _v4941 = v4943 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v4944 : string = "String::from($0)"
                                                                                                    let v4945 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4936 v4944 
                                                                                                    let _v4941 = v4945 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v4946 : string = "String::from($0)"
                                                                                                    let v4947 : std_string_String = Fable.Core.RustInterop.emitRustExpr v4936 v4946 
                                                                                                    let _v4941 = v4947 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v4948 : std_string_String = v4936 |> unbox<std_string_String>
                                                                                                    let _v4941 = v4948 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v4951 : std_string_String = v4936 |> unbox<std_string_String>
                                                                                                    let _v4941 = v4951 
                                                                                                    #endif
#else
                                                                                                    let v4954 : std_string_String = v4936 |> unbox<std_string_String>
                                                                                                    let _v4941 = v4954 
                                                                                                    #endif
                                                                                                    let v4957 : std_string_String = _v4941 
                                                                                                    let v4962 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v4963 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v4964 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4957 v4963 
                                                                                                    let _v4962 = v4964 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v4965 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v4966 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4957 v4965 
                                                                                                    let _v4962 = v4966 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v4967 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v4968 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v4957 v4967 
                                                                                                    let _v4962 = v4968 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v4969 : std_path_PathBuf = v4957 |> std_path_PathBuf 
                                                                                                    let _v4962 = v4969 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v4972 : std_path_PathBuf = v4957 |> std_path_PathBuf 
                                                                                                    let _v4962 = v4972 
                                                                                                    #endif
#else
                                                                                                    let v4975 : std_path_PathBuf = v4957 |> std_path_PathBuf 
                                                                                                    let _v4962 = v4975 
                                                                                                    #endif
                                                                                                    let v4978 : std_path_PathBuf = _v4962 
                                                                                                    let v4983 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v4984 : string = "Ok($0)"
                                                                                                    let v4985 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4978 v4984 
                                                                                                    let _v4983 = v4985 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v4986 : string = "Ok($0)"
                                                                                                    let v4987 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4978 v4986 
                                                                                                    let _v4983 = v4987 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v4988 : string = "Ok($0)"
                                                                                                    let v4989 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v4978 v4988 
                                                                                                    let _v4983 = v4989 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v4990 : Result<std_path_PathBuf, std_io_Error> = v4978 |> Ok
                                                                                                    let _v4983 = v4990 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v4991 : Result<std_path_PathBuf, std_io_Error> = v4978 |> Ok
                                                                                                    let _v4983 = v4991 
                                                                                                    #endif
#else
                                                                                                    let v4992 : Result<std_path_PathBuf, std_io_Error> = v4978 |> Ok
                                                                                                    let _v4983 = v4992 
                                                                                                    #endif
                                                                                                    let v4993 : Result<std_path_PathBuf, std_io_Error> = _v4983 
                                                                                                    v4993
                                                                                            else
                                                                                                let v5026 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3215} / path': {v3180} / name: {v3216}"
                                                                                                let v5027 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v5028 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v5029 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5026 v5028 
                                                                                                let _v5027 = v5029 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v5030 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v5031 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5026 v5030 
                                                                                                let _v5027 = v5031 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v5032 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v5033 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5026 v5032 
                                                                                                let _v5027 = v5033 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v5034 : std_io_Error = v5026 
                                                                                                let _v5027 = v5034 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v5035 : std_io_Error = v5026 
                                                                                                let _v5027 = v5035 
                                                                                                #endif
#else
                                                                                                let v5036 : std_io_Error = v5026 
                                                                                                let _v5027 = v5036 
                                                                                                #endif
                                                                                                let v5037 : std_io_Error = _v5027 
                                                                                                let v5040 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v5041 : string = "Err($0)"
                                                                                                let v5042 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5037 v5041 
                                                                                                let _v5040 = v5042 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v5043 : string = "Err($0)"
                                                                                                let v5044 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5037 v5043 
                                                                                                let _v5040 = v5044 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v5045 : string = "Err($0)"
                                                                                                let v5046 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5037 v5045 
                                                                                                let _v5040 = v5046 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v5047 : Result<std_path_PathBuf, std_io_Error> = v5037 |> Error
                                                                                                let _v5040 = v5047 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v5048 : Result<std_path_PathBuf, std_io_Error> = v5037 |> Error
                                                                                                let _v5040 = v5048 
                                                                                                #endif
#else
                                                                                                let v5049 : Result<std_path_PathBuf, std_io_Error> = v5037 |> Error
                                                                                                let _v5040 = v5049 
                                                                                                #endif
                                                                                                let v5050 : Result<std_path_PathBuf, std_io_Error> = _v5040 
                                                                                                v5050
                                                                                        | _ ->
                                                                                            let v5054 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3215} / path': {v3180} / name: {v3216}"
                                                                                            let v5055 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v5056 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v5057 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5054 v5056 
                                                                                            let _v5055 = v5057 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v5058 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v5059 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5054 v5058 
                                                                                            let _v5055 = v5059 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v5060 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v5061 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5054 v5060 
                                                                                            let _v5055 = v5061 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v5062 : std_io_Error = v5054 
                                                                                            let _v5055 = v5062 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v5063 : std_io_Error = v5054 
                                                                                            let _v5055 = v5063 
                                                                                            #endif
#else
                                                                                            let v5064 : std_io_Error = v5054 
                                                                                            let _v5055 = v5064 
                                                                                            #endif
                                                                                            let v5065 : std_io_Error = _v5055 
                                                                                            let v5068 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v5069 : string = "Err($0)"
                                                                                            let v5070 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5065 v5069 
                                                                                            let _v5068 = v5070 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v5071 : string = "Err($0)"
                                                                                            let v5072 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5065 v5071 
                                                                                            let _v5068 = v5072 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v5073 : string = "Err($0)"
                                                                                            let v5074 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5065 v5073 
                                                                                            let _v5068 = v5074 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v5075 : Result<std_path_PathBuf, std_io_Error> = v5065 |> Error
                                                                                            let _v5068 = v5075 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v5076 : Result<std_path_PathBuf, std_io_Error> = v5065 |> Error
                                                                                            let _v5068 = v5076 
                                                                                            #endif
#else
                                                                                            let v5077 : Result<std_path_PathBuf, std_io_Error> = v5065 |> Error
                                                                                            let _v5068 = v5077 
                                                                                            #endif
                                                                                            let v5078 : Result<std_path_PathBuf, std_io_Error> = _v5068 
                                                                                            v5078
                                                                                    | US13_0(v3201) -> (* Ok *)
                                                                                        let v3202 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v3203 : string = "Ok($0)"
                                                                                        let v3204 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3201 v3203 
                                                                                        let _v3202 = v3204 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v3205 : string = "Ok($0)"
                                                                                        let v3206 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3201 v3205 
                                                                                        let _v3202 = v3206 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v3207 : string = "Ok($0)"
                                                                                        let v3208 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3201 v3207 
                                                                                        let _v3202 = v3208 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v3209 : Result<std_path_PathBuf, std_io_Error> = v3201 |> Ok
                                                                                        let _v3202 = v3209 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v3210 : Result<std_path_PathBuf, std_io_Error> = v3201 |> Ok
                                                                                        let _v3202 = v3210 
                                                                                        #endif
#else
                                                                                        let v3211 : Result<std_path_PathBuf, std_io_Error> = v3201 |> Ok
                                                                                        let _v3202 = v3211 
                                                                                        #endif
                                                                                        let v3212 : Result<std_path_PathBuf, std_io_Error> = _v3202 
                                                                                        v3212
                                                                                let v5084 : (std_io_Error -> string) = method76()
                                                                                let v5085 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5086 : string = "$0.map_err(|x| $1(x))"
                                                                                let v5087 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5083, v5084) v5086 
                                                                                let _v5085 = v5087 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5088 : string = "$0.map_err(|x| $1(x))"
                                                                                let v5089 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5083, v5084) v5088 
                                                                                let _v5085 = v5089 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5090 : string = "$0.map_err(|x| $1(x))"
                                                                                let v5091 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5083, v5084) v5090 
                                                                                let _v5085 = v5091 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5092 : Result<std_path_PathBuf, string> = match v5083 with Ok x -> Ok x | Error x -> Error (v5084 x)
                                                                                let _v5085 = v5092 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5093 : Result<std_path_PathBuf, string> = match v5083 with Ok x -> Ok x | Error x -> Error (v5084 x)
                                                                                let _v5085 = v5093 
                                                                                #endif
#else
                                                                                let v5094 : Result<std_path_PathBuf, string> = match v5083 with Ok x -> Ok x | Error x -> Error (v5084 x)
                                                                                let _v5085 = v5094 
                                                                                #endif
                                                                                let v5095 : Result<std_path_PathBuf, string> = _v5085 
                                                                                let v5098 : US13 = match v5095 with Ok x -> v2977 x | Error x -> v2978 x
                                                                                match v5098 with
                                                                                | US13_1(v5201) -> (* Error *)
                                                                                    let v5202 : string = $"file_system.read_link / error': {v5201} / error: {v3160} / name: {v3161}"
                                                                                    let v5203 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v5204 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v5205 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5202 v5204 
                                                                                    let _v5203 = v5205 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v5206 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v5207 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5202 v5206 
                                                                                    let _v5203 = v5207 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v5208 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v5209 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5202 v5208 
                                                                                    let _v5203 = v5209 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v5210 : std_io_Error = v5202 
                                                                                    let _v5203 = v5210 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v5211 : std_io_Error = v5202 
                                                                                    let _v5203 = v5211 
                                                                                    #endif
#else
                                                                                    let v5212 : std_io_Error = v5202 
                                                                                    let _v5203 = v5212 
                                                                                    #endif
                                                                                    let v5213 : std_io_Error = _v5203 
                                                                                    let v5216 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v5217 : string = "Err($0)"
                                                                                    let v5218 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5213 v5217 
                                                                                    let _v5216 = v5218 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v5219 : string = "Err($0)"
                                                                                    let v5220 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5213 v5219 
                                                                                    let _v5216 = v5220 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v5221 : string = "Err($0)"
                                                                                    let v5222 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5213 v5221 
                                                                                    let _v5216 = v5222 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v5223 : Result<std_path_PathBuf, std_io_Error> = v5213 |> Error
                                                                                    let _v5216 = v5223 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v5224 : Result<std_path_PathBuf, std_io_Error> = v5213 |> Error
                                                                                    let _v5216 = v5224 
                                                                                    #endif
#else
                                                                                    let v5225 : Result<std_path_PathBuf, std_io_Error> = v5213 |> Error
                                                                                    let _v5216 = v5225 
                                                                                    #endif
                                                                                    let v5226 : Result<std_path_PathBuf, std_io_Error> = _v5216 
                                                                                    v5226
                                                                                | US13_0(v5099) -> (* Ok *)
                                                                                    let v5100 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v5101 : string = "$0.display()"
                                                                                    let v5102 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5099 v5101 
                                                                                    let _v5100 = v5102 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v5103 : string = "$0.display()"
                                                                                    let v5104 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5099 v5103 
                                                                                    let _v5100 = v5104 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v5105 : string = "$0.display()"
                                                                                    let v5106 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5099 v5105 
                                                                                    let _v5100 = v5106 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v5107 : std_path_Display = v5099 |> unbox<std_path_Display>
                                                                                    let _v5100 = v5107 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v5110 : std_path_Display = v5099 |> unbox<std_path_Display>
                                                                                    let _v5100 = v5110 
                                                                                    #endif
#else
                                                                                    let v5113 : std_path_Display = v5099 |> unbox<std_path_Display>
                                                                                    let _v5100 = v5113 
                                                                                    #endif
                                                                                    let v5116 : std_path_Display = _v5100 
                                                                                    let v5121 : string = v5116 |> string 
                                                                                    let v5124 : string = method56(v5121, v3161)
                                                                                    let v5125 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v5126 : string = "&*$0"
                                                                                    let v5127 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5124 v5126 
                                                                                    let _v5125 = v5127 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v5128 : string = "&*$0"
                                                                                    let v5129 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5124 v5128 
                                                                                    let _v5125 = v5129 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v5130 : string = "&*$0"
                                                                                    let v5131 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5124 v5130 
                                                                                    let _v5125 = v5131 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v5132 : Ref<Str> = v5124 |> unbox<Ref<Str>>
                                                                                    let _v5125 = v5132 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v5135 : Ref<Str> = v5124 |> unbox<Ref<Str>>
                                                                                    let _v5125 = v5135 
                                                                                    #endif
#else
                                                                                    let v5138 : Ref<Str> = v5124 |> unbox<Ref<Str>>
                                                                                    let _v5125 = v5138 
                                                                                    #endif
                                                                                    let v5141 : Ref<Str> = _v5125 
                                                                                    let v5146 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v5147 : string = "String::from($0)"
                                                                                    let v5148 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5141 v5147 
                                                                                    let _v5146 = v5148 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v5149 : string = "String::from($0)"
                                                                                    let v5150 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5141 v5149 
                                                                                    let _v5146 = v5150 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v5151 : string = "String::from($0)"
                                                                                    let v5152 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5141 v5151 
                                                                                    let _v5146 = v5152 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v5153 : std_string_String = v5141 |> unbox<std_string_String>
                                                                                    let _v5146 = v5153 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v5156 : std_string_String = v5141 |> unbox<std_string_String>
                                                                                    let _v5146 = v5156 
                                                                                    #endif
#else
                                                                                    let v5159 : std_string_String = v5141 |> unbox<std_string_String>
                                                                                    let _v5146 = v5159 
                                                                                    #endif
                                                                                    let v5162 : std_string_String = _v5146 
                                                                                    let v5167 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v5168 : string = "std::path::PathBuf::from($0)"
                                                                                    let v5169 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5162 v5168 
                                                                                    let _v5167 = v5169 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v5170 : string = "std::path::PathBuf::from($0)"
                                                                                    let v5171 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5162 v5170 
                                                                                    let _v5167 = v5171 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v5172 : string = "std::path::PathBuf::from($0)"
                                                                                    let v5173 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5162 v5172 
                                                                                    let _v5167 = v5173 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v5174 : std_path_PathBuf = v5162 |> std_path_PathBuf 
                                                                                    let _v5167 = v5174 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v5177 : std_path_PathBuf = v5162 |> std_path_PathBuf 
                                                                                    let _v5167 = v5177 
                                                                                    #endif
#else
                                                                                    let v5180 : std_path_PathBuf = v5162 |> std_path_PathBuf 
                                                                                    let _v5167 = v5180 
                                                                                    #endif
                                                                                    let v5183 : std_path_PathBuf = _v5167 
                                                                                    let v5188 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v5189 : string = "Ok($0)"
                                                                                    let v5190 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5183 v5189 
                                                                                    let _v5188 = v5190 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v5191 : string = "Ok($0)"
                                                                                    let v5192 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5183 v5191 
                                                                                    let _v5188 = v5192 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v5193 : string = "Ok($0)"
                                                                                    let v5194 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5183 v5193 
                                                                                    let _v5188 = v5194 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v5195 : Result<std_path_PathBuf, std_io_Error> = v5183 |> Ok
                                                                                    let _v5188 = v5195 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v5196 : Result<std_path_PathBuf, std_io_Error> = v5183 |> Ok
                                                                                    let _v5188 = v5196 
                                                                                    #endif
#else
                                                                                    let v5197 : Result<std_path_PathBuf, std_io_Error> = v5183 |> Ok
                                                                                    let _v5188 = v5197 
                                                                                    #endif
                                                                                    let v5198 : Result<std_path_PathBuf, std_io_Error> = _v5188 
                                                                                    v5198
                                                                            else
                                                                                let v5231 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3160} / path': {v3125} / name: {v3161}"
                                                                                let v5232 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5233 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v5234 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5231 v5233 
                                                                                let _v5232 = v5234 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5235 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v5236 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5231 v5235 
                                                                                let _v5232 = v5236 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5237 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v5238 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5231 v5237 
                                                                                let _v5232 = v5238 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5239 : std_io_Error = v5231 
                                                                                let _v5232 = v5239 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5240 : std_io_Error = v5231 
                                                                                let _v5232 = v5240 
                                                                                #endif
#else
                                                                                let v5241 : std_io_Error = v5231 
                                                                                let _v5232 = v5241 
                                                                                #endif
                                                                                let v5242 : std_io_Error = _v5232 
                                                                                let v5245 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v5246 : string = "Err($0)"
                                                                                let v5247 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5242 v5246 
                                                                                let _v5245 = v5247 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v5248 : string = "Err($0)"
                                                                                let v5249 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5242 v5248 
                                                                                let _v5245 = v5249 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v5250 : string = "Err($0)"
                                                                                let v5251 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5242 v5250 
                                                                                let _v5245 = v5251 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v5252 : Result<std_path_PathBuf, std_io_Error> = v5242 |> Error
                                                                                let _v5245 = v5252 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v5253 : Result<std_path_PathBuf, std_io_Error> = v5242 |> Error
                                                                                let _v5245 = v5253 
                                                                                #endif
#else
                                                                                let v5254 : Result<std_path_PathBuf, std_io_Error> = v5242 |> Error
                                                                                let _v5245 = v5254 
                                                                                #endif
                                                                                let v5255 : Result<std_path_PathBuf, std_io_Error> = _v5245 
                                                                                v5255
                                                                        | _ ->
                                                                            let v5259 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3160} / path': {v3125} / name: {v3161}"
                                                                            let v5260 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v5261 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v5262 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5259 v5261 
                                                                            let _v5260 = v5262 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v5263 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v5264 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5259 v5263 
                                                                            let _v5260 = v5264 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v5265 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v5266 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5259 v5265 
                                                                            let _v5260 = v5266 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v5267 : std_io_Error = v5259 
                                                                            let _v5260 = v5267 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v5268 : std_io_Error = v5259 
                                                                            let _v5260 = v5268 
                                                                            #endif
#else
                                                                            let v5269 : std_io_Error = v5259 
                                                                            let _v5260 = v5269 
                                                                            #endif
                                                                            let v5270 : std_io_Error = _v5260 
                                                                            let v5273 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v5274 : string = "Err($0)"
                                                                            let v5275 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5270 v5274 
                                                                            let _v5273 = v5275 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v5276 : string = "Err($0)"
                                                                            let v5277 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5270 v5276 
                                                                            let _v5273 = v5277 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v5278 : string = "Err($0)"
                                                                            let v5279 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5270 v5278 
                                                                            let _v5273 = v5279 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v5280 : Result<std_path_PathBuf, std_io_Error> = v5270 |> Error
                                                                            let _v5273 = v5280 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v5281 : Result<std_path_PathBuf, std_io_Error> = v5270 |> Error
                                                                            let _v5273 = v5281 
                                                                            #endif
#else
                                                                            let v5282 : Result<std_path_PathBuf, std_io_Error> = v5270 |> Error
                                                                            let _v5273 = v5282 
                                                                            #endif
                                                                            let v5283 : Result<std_path_PathBuf, std_io_Error> = _v5273 
                                                                            v5283
                                                                    | US13_0(v3146) -> (* Ok *)
                                                                        let v3147 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v3148 : string = "Ok($0)"
                                                                        let v3149 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3146 v3148 
                                                                        let _v3147 = v3149 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v3150 : string = "Ok($0)"
                                                                        let v3151 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3146 v3150 
                                                                        let _v3147 = v3151 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v3152 : string = "Ok($0)"
                                                                        let v3153 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3146 v3152 
                                                                        let _v3147 = v3153 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v3154 : Result<std_path_PathBuf, std_io_Error> = v3146 |> Ok
                                                                        let _v3147 = v3154 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v3155 : Result<std_path_PathBuf, std_io_Error> = v3146 |> Ok
                                                                        let _v3147 = v3155 
                                                                        #endif
#else
                                                                        let v3156 : Result<std_path_PathBuf, std_io_Error> = v3146 |> Ok
                                                                        let _v3147 = v3156 
                                                                        #endif
                                                                        let v3157 : Result<std_path_PathBuf, std_io_Error> = _v3147 
                                                                        v3157
                                                                let v5289 : (std_io_Error -> string) = method76()
                                                                let v5290 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5291 : string = "$0.map_err(|x| $1(x))"
                                                                let v5292 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5288, v5289) v5291 
                                                                let _v5290 = v5292 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5293 : string = "$0.map_err(|x| $1(x))"
                                                                let v5294 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5288, v5289) v5293 
                                                                let _v5290 = v5294 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5295 : string = "$0.map_err(|x| $1(x))"
                                                                let v5296 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5288, v5289) v5295 
                                                                let _v5290 = v5296 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5297 : Result<std_path_PathBuf, string> = match v5288 with Ok x -> Ok x | Error x -> Error (v5289 x)
                                                                let _v5290 = v5297 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5298 : Result<std_path_PathBuf, string> = match v5288 with Ok x -> Ok x | Error x -> Error (v5289 x)
                                                                let _v5290 = v5298 
                                                                #endif
#else
                                                                let v5299 : Result<std_path_PathBuf, string> = match v5288 with Ok x -> Ok x | Error x -> Error (v5289 x)
                                                                let _v5290 = v5299 
                                                                #endif
                                                                let v5300 : Result<std_path_PathBuf, string> = _v5290 
                                                                let v5303 : US13 = match v5300 with Ok x -> v2977 x | Error x -> v2978 x
                                                                match v5303 with
                                                                | US13_1(v5406) -> (* Error *)
                                                                    let v5407 : string = $"file_system.read_link / error': {v5406} / error: {v3105} / name: {v3106}"
                                                                    let v5408 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v5409 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v5410 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5407 v5409 
                                                                    let _v5408 = v5410 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v5411 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v5412 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5407 v5411 
                                                                    let _v5408 = v5412 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v5413 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v5414 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5407 v5413 
                                                                    let _v5408 = v5414 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v5415 : std_io_Error = v5407 
                                                                    let _v5408 = v5415 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v5416 : std_io_Error = v5407 
                                                                    let _v5408 = v5416 
                                                                    #endif
#else
                                                                    let v5417 : std_io_Error = v5407 
                                                                    let _v5408 = v5417 
                                                                    #endif
                                                                    let v5418 : std_io_Error = _v5408 
                                                                    let v5421 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v5422 : string = "Err($0)"
                                                                    let v5423 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5418 v5422 
                                                                    let _v5421 = v5423 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v5424 : string = "Err($0)"
                                                                    let v5425 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5418 v5424 
                                                                    let _v5421 = v5425 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v5426 : string = "Err($0)"
                                                                    let v5427 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5418 v5426 
                                                                    let _v5421 = v5427 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v5428 : Result<std_path_PathBuf, std_io_Error> = v5418 |> Error
                                                                    let _v5421 = v5428 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v5429 : Result<std_path_PathBuf, std_io_Error> = v5418 |> Error
                                                                    let _v5421 = v5429 
                                                                    #endif
#else
                                                                    let v5430 : Result<std_path_PathBuf, std_io_Error> = v5418 |> Error
                                                                    let _v5421 = v5430 
                                                                    #endif
                                                                    let v5431 : Result<std_path_PathBuf, std_io_Error> = _v5421 
                                                                    v5431
                                                                | US13_0(v5304) -> (* Ok *)
                                                                    let v5305 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v5306 : string = "$0.display()"
                                                                    let v5307 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5304 v5306 
                                                                    let _v5305 = v5307 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v5308 : string = "$0.display()"
                                                                    let v5309 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5304 v5308 
                                                                    let _v5305 = v5309 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v5310 : string = "$0.display()"
                                                                    let v5311 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5304 v5310 
                                                                    let _v5305 = v5311 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v5312 : std_path_Display = v5304 |> unbox<std_path_Display>
                                                                    let _v5305 = v5312 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v5315 : std_path_Display = v5304 |> unbox<std_path_Display>
                                                                    let _v5305 = v5315 
                                                                    #endif
#else
                                                                    let v5318 : std_path_Display = v5304 |> unbox<std_path_Display>
                                                                    let _v5305 = v5318 
                                                                    #endif
                                                                    let v5321 : std_path_Display = _v5305 
                                                                    let v5326 : string = v5321 |> string 
                                                                    let v5329 : string = method56(v5326, v3106)
                                                                    let v5330 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v5331 : string = "&*$0"
                                                                    let v5332 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5329 v5331 
                                                                    let _v5330 = v5332 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v5333 : string = "&*$0"
                                                                    let v5334 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5329 v5333 
                                                                    let _v5330 = v5334 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v5335 : string = "&*$0"
                                                                    let v5336 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5329 v5335 
                                                                    let _v5330 = v5336 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v5337 : Ref<Str> = v5329 |> unbox<Ref<Str>>
                                                                    let _v5330 = v5337 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v5340 : Ref<Str> = v5329 |> unbox<Ref<Str>>
                                                                    let _v5330 = v5340 
                                                                    #endif
#else
                                                                    let v5343 : Ref<Str> = v5329 |> unbox<Ref<Str>>
                                                                    let _v5330 = v5343 
                                                                    #endif
                                                                    let v5346 : Ref<Str> = _v5330 
                                                                    let v5351 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v5352 : string = "String::from($0)"
                                                                    let v5353 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5346 v5352 
                                                                    let _v5351 = v5353 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v5354 : string = "String::from($0)"
                                                                    let v5355 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5346 v5354 
                                                                    let _v5351 = v5355 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v5356 : string = "String::from($0)"
                                                                    let v5357 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5346 v5356 
                                                                    let _v5351 = v5357 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v5358 : std_string_String = v5346 |> unbox<std_string_String>
                                                                    let _v5351 = v5358 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v5361 : std_string_String = v5346 |> unbox<std_string_String>
                                                                    let _v5351 = v5361 
                                                                    #endif
#else
                                                                    let v5364 : std_string_String = v5346 |> unbox<std_string_String>
                                                                    let _v5351 = v5364 
                                                                    #endif
                                                                    let v5367 : std_string_String = _v5351 
                                                                    let v5372 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v5373 : string = "std::path::PathBuf::from($0)"
                                                                    let v5374 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5367 v5373 
                                                                    let _v5372 = v5374 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v5375 : string = "std::path::PathBuf::from($0)"
                                                                    let v5376 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5367 v5375 
                                                                    let _v5372 = v5376 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v5377 : string = "std::path::PathBuf::from($0)"
                                                                    let v5378 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5367 v5377 
                                                                    let _v5372 = v5378 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v5379 : std_path_PathBuf = v5367 |> std_path_PathBuf 
                                                                    let _v5372 = v5379 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v5382 : std_path_PathBuf = v5367 |> std_path_PathBuf 
                                                                    let _v5372 = v5382 
                                                                    #endif
#else
                                                                    let v5385 : std_path_PathBuf = v5367 |> std_path_PathBuf 
                                                                    let _v5372 = v5385 
                                                                    #endif
                                                                    let v5388 : std_path_PathBuf = _v5372 
                                                                    let v5393 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v5394 : string = "Ok($0)"
                                                                    let v5395 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5388 v5394 
                                                                    let _v5393 = v5395 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v5396 : string = "Ok($0)"
                                                                    let v5397 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5388 v5396 
                                                                    let _v5393 = v5397 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v5398 : string = "Ok($0)"
                                                                    let v5399 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5388 v5398 
                                                                    let _v5393 = v5399 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v5400 : Result<std_path_PathBuf, std_io_Error> = v5388 |> Ok
                                                                    let _v5393 = v5400 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v5401 : Result<std_path_PathBuf, std_io_Error> = v5388 |> Ok
                                                                    let _v5393 = v5401 
                                                                    #endif
#else
                                                                    let v5402 : Result<std_path_PathBuf, std_io_Error> = v5388 |> Ok
                                                                    let _v5393 = v5402 
                                                                    #endif
                                                                    let v5403 : Result<std_path_PathBuf, std_io_Error> = _v5393 
                                                                    v5403
                                                            else
                                                                let v5436 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3105} / path': {v3070} / name: {v3106}"
                                                                let v5437 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5438 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v5439 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5436 v5438 
                                                                let _v5437 = v5439 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5440 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v5441 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5436 v5440 
                                                                let _v5437 = v5441 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5442 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v5443 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5436 v5442 
                                                                let _v5437 = v5443 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5444 : std_io_Error = v5436 
                                                                let _v5437 = v5444 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5445 : std_io_Error = v5436 
                                                                let _v5437 = v5445 
                                                                #endif
#else
                                                                let v5446 : std_io_Error = v5436 
                                                                let _v5437 = v5446 
                                                                #endif
                                                                let v5447 : std_io_Error = _v5437 
                                                                let v5450 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v5451 : string = "Err($0)"
                                                                let v5452 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5447 v5451 
                                                                let _v5450 = v5452 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v5453 : string = "Err($0)"
                                                                let v5454 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5447 v5453 
                                                                let _v5450 = v5454 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v5455 : string = "Err($0)"
                                                                let v5456 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5447 v5455 
                                                                let _v5450 = v5456 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v5457 : Result<std_path_PathBuf, std_io_Error> = v5447 |> Error
                                                                let _v5450 = v5457 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v5458 : Result<std_path_PathBuf, std_io_Error> = v5447 |> Error
                                                                let _v5450 = v5458 
                                                                #endif
#else
                                                                let v5459 : Result<std_path_PathBuf, std_io_Error> = v5447 |> Error
                                                                let _v5450 = v5459 
                                                                #endif
                                                                let v5460 : Result<std_path_PathBuf, std_io_Error> = _v5450 
                                                                v5460
                                                        | _ ->
                                                            let v5464 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3105} / path': {v3070} / name: {v3106}"
                                                            let v5465 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v5466 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v5467 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5464 v5466 
                                                            let _v5465 = v5467 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v5468 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v5469 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5464 v5468 
                                                            let _v5465 = v5469 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v5470 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v5471 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5464 v5470 
                                                            let _v5465 = v5471 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v5472 : std_io_Error = v5464 
                                                            let _v5465 = v5472 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v5473 : std_io_Error = v5464 
                                                            let _v5465 = v5473 
                                                            #endif
#else
                                                            let v5474 : std_io_Error = v5464 
                                                            let _v5465 = v5474 
                                                            #endif
                                                            let v5475 : std_io_Error = _v5465 
                                                            let v5478 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v5479 : string = "Err($0)"
                                                            let v5480 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5475 v5479 
                                                            let _v5478 = v5480 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v5481 : string = "Err($0)"
                                                            let v5482 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5475 v5481 
                                                            let _v5478 = v5482 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v5483 : string = "Err($0)"
                                                            let v5484 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5475 v5483 
                                                            let _v5478 = v5484 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v5485 : Result<std_path_PathBuf, std_io_Error> = v5475 |> Error
                                                            let _v5478 = v5485 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v5486 : Result<std_path_PathBuf, std_io_Error> = v5475 |> Error
                                                            let _v5478 = v5486 
                                                            #endif
#else
                                                            let v5487 : Result<std_path_PathBuf, std_io_Error> = v5475 |> Error
                                                            let _v5478 = v5487 
                                                            #endif
                                                            let v5488 : Result<std_path_PathBuf, std_io_Error> = _v5478 
                                                            v5488
                                                    | US13_0(v3091) -> (* Ok *)
                                                        let v3092 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v3093 : string = "Ok($0)"
                                                        let v3094 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3091 v3093 
                                                        let _v3092 = v3094 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v3095 : string = "Ok($0)"
                                                        let v3096 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3091 v3095 
                                                        let _v3092 = v3096 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v3097 : string = "Ok($0)"
                                                        let v3098 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3091 v3097 
                                                        let _v3092 = v3098 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v3099 : Result<std_path_PathBuf, std_io_Error> = v3091 |> Ok
                                                        let _v3092 = v3099 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v3100 : Result<std_path_PathBuf, std_io_Error> = v3091 |> Ok
                                                        let _v3092 = v3100 
                                                        #endif
#else
                                                        let v3101 : Result<std_path_PathBuf, std_io_Error> = v3091 |> Ok
                                                        let _v3092 = v3101 
                                                        #endif
                                                        let v3102 : Result<std_path_PathBuf, std_io_Error> = _v3092 
                                                        v3102
                                                let v5494 : (std_io_Error -> string) = method76()
                                                let v5495 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5496 : string = "$0.map_err(|x| $1(x))"
                                                let v5497 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5493, v5494) v5496 
                                                let _v5495 = v5497 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5498 : string = "$0.map_err(|x| $1(x))"
                                                let v5499 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5493, v5494) v5498 
                                                let _v5495 = v5499 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5500 : string = "$0.map_err(|x| $1(x))"
                                                let v5501 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5493, v5494) v5500 
                                                let _v5495 = v5501 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5502 : Result<std_path_PathBuf, string> = match v5493 with Ok x -> Ok x | Error x -> Error (v5494 x)
                                                let _v5495 = v5502 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5503 : Result<std_path_PathBuf, string> = match v5493 with Ok x -> Ok x | Error x -> Error (v5494 x)
                                                let _v5495 = v5503 
                                                #endif
#else
                                                let v5504 : Result<std_path_PathBuf, string> = match v5493 with Ok x -> Ok x | Error x -> Error (v5494 x)
                                                let _v5495 = v5504 
                                                #endif
                                                let v5505 : Result<std_path_PathBuf, string> = _v5495 
                                                let v5508 : US13 = match v5505 with Ok x -> v2977 x | Error x -> v2978 x
                                                match v5508 with
                                                | US13_1(v5611) -> (* Error *)
                                                    let v5612 : string = $"file_system.read_link / error': {v5611} / error: {v3050} / name: {v3051}"
                                                    let v5613 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v5614 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v5615 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5612 v5614 
                                                    let _v5613 = v5615 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v5616 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v5617 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5612 v5616 
                                                    let _v5613 = v5617 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v5618 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v5619 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5612 v5618 
                                                    let _v5613 = v5619 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v5620 : std_io_Error = v5612 
                                                    let _v5613 = v5620 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v5621 : std_io_Error = v5612 
                                                    let _v5613 = v5621 
                                                    #endif
#else
                                                    let v5622 : std_io_Error = v5612 
                                                    let _v5613 = v5622 
                                                    #endif
                                                    let v5623 : std_io_Error = _v5613 
                                                    let v5626 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v5627 : string = "Err($0)"
                                                    let v5628 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5623 v5627 
                                                    let _v5626 = v5628 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v5629 : string = "Err($0)"
                                                    let v5630 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5623 v5629 
                                                    let _v5626 = v5630 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v5631 : string = "Err($0)"
                                                    let v5632 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5623 v5631 
                                                    let _v5626 = v5632 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v5633 : Result<std_path_PathBuf, std_io_Error> = v5623 |> Error
                                                    let _v5626 = v5633 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v5634 : Result<std_path_PathBuf, std_io_Error> = v5623 |> Error
                                                    let _v5626 = v5634 
                                                    #endif
#else
                                                    let v5635 : Result<std_path_PathBuf, std_io_Error> = v5623 |> Error
                                                    let _v5626 = v5635 
                                                    #endif
                                                    let v5636 : Result<std_path_PathBuf, std_io_Error> = _v5626 
                                                    v5636
                                                | US13_0(v5509) -> (* Ok *)
                                                    let v5510 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v5511 : string = "$0.display()"
                                                    let v5512 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5509 v5511 
                                                    let _v5510 = v5512 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v5513 : string = "$0.display()"
                                                    let v5514 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5509 v5513 
                                                    let _v5510 = v5514 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v5515 : string = "$0.display()"
                                                    let v5516 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5509 v5515 
                                                    let _v5510 = v5516 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v5517 : std_path_Display = v5509 |> unbox<std_path_Display>
                                                    let _v5510 = v5517 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v5520 : std_path_Display = v5509 |> unbox<std_path_Display>
                                                    let _v5510 = v5520 
                                                    #endif
#else
                                                    let v5523 : std_path_Display = v5509 |> unbox<std_path_Display>
                                                    let _v5510 = v5523 
                                                    #endif
                                                    let v5526 : std_path_Display = _v5510 
                                                    let v5531 : string = v5526 |> string 
                                                    let v5534 : string = method56(v5531, v3051)
                                                    let v5535 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v5536 : string = "&*$0"
                                                    let v5537 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5534 v5536 
                                                    let _v5535 = v5537 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v5538 : string = "&*$0"
                                                    let v5539 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5534 v5538 
                                                    let _v5535 = v5539 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v5540 : string = "&*$0"
                                                    let v5541 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5534 v5540 
                                                    let _v5535 = v5541 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v5542 : Ref<Str> = v5534 |> unbox<Ref<Str>>
                                                    let _v5535 = v5542 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v5545 : Ref<Str> = v5534 |> unbox<Ref<Str>>
                                                    let _v5535 = v5545 
                                                    #endif
#else
                                                    let v5548 : Ref<Str> = v5534 |> unbox<Ref<Str>>
                                                    let _v5535 = v5548 
                                                    #endif
                                                    let v5551 : Ref<Str> = _v5535 
                                                    let v5556 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v5557 : string = "String::from($0)"
                                                    let v5558 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5551 v5557 
                                                    let _v5556 = v5558 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v5559 : string = "String::from($0)"
                                                    let v5560 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5551 v5559 
                                                    let _v5556 = v5560 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v5561 : string = "String::from($0)"
                                                    let v5562 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5551 v5561 
                                                    let _v5556 = v5562 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v5563 : std_string_String = v5551 |> unbox<std_string_String>
                                                    let _v5556 = v5563 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v5566 : std_string_String = v5551 |> unbox<std_string_String>
                                                    let _v5556 = v5566 
                                                    #endif
#else
                                                    let v5569 : std_string_String = v5551 |> unbox<std_string_String>
                                                    let _v5556 = v5569 
                                                    #endif
                                                    let v5572 : std_string_String = _v5556 
                                                    let v5577 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v5578 : string = "std::path::PathBuf::from($0)"
                                                    let v5579 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5572 v5578 
                                                    let _v5577 = v5579 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v5580 : string = "std::path::PathBuf::from($0)"
                                                    let v5581 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5572 v5580 
                                                    let _v5577 = v5581 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v5582 : string = "std::path::PathBuf::from($0)"
                                                    let v5583 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5572 v5582 
                                                    let _v5577 = v5583 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v5584 : std_path_PathBuf = v5572 |> std_path_PathBuf 
                                                    let _v5577 = v5584 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v5587 : std_path_PathBuf = v5572 |> std_path_PathBuf 
                                                    let _v5577 = v5587 
                                                    #endif
#else
                                                    let v5590 : std_path_PathBuf = v5572 |> std_path_PathBuf 
                                                    let _v5577 = v5590 
                                                    #endif
                                                    let v5593 : std_path_PathBuf = _v5577 
                                                    let v5598 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v5599 : string = "Ok($0)"
                                                    let v5600 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5593 v5599 
                                                    let _v5598 = v5600 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v5601 : string = "Ok($0)"
                                                    let v5602 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5593 v5601 
                                                    let _v5598 = v5602 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v5603 : string = "Ok($0)"
                                                    let v5604 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5593 v5603 
                                                    let _v5598 = v5604 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v5605 : Result<std_path_PathBuf, std_io_Error> = v5593 |> Ok
                                                    let _v5598 = v5605 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v5606 : Result<std_path_PathBuf, std_io_Error> = v5593 |> Ok
                                                    let _v5598 = v5606 
                                                    #endif
#else
                                                    let v5607 : Result<std_path_PathBuf, std_io_Error> = v5593 |> Ok
                                                    let _v5598 = v5607 
                                                    #endif
                                                    let v5608 : Result<std_path_PathBuf, std_io_Error> = _v5598 
                                                    v5608
                                            else
                                                let v5641 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3050} / path': {v3014} / name: {v3051}"
                                                let v5642 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5643 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v5644 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5641 v5643 
                                                let _v5642 = v5644 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5645 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v5646 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5641 v5645 
                                                let _v5642 = v5646 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5647 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v5648 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5641 v5647 
                                                let _v5642 = v5648 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5649 : std_io_Error = v5641 
                                                let _v5642 = v5649 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5650 : std_io_Error = v5641 
                                                let _v5642 = v5650 
                                                #endif
#else
                                                let v5651 : std_io_Error = v5641 
                                                let _v5642 = v5651 
                                                #endif
                                                let v5652 : std_io_Error = _v5642 
                                                let v5655 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v5656 : string = "Err($0)"
                                                let v5657 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5652 v5656 
                                                let _v5655 = v5657 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v5658 : string = "Err($0)"
                                                let v5659 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5652 v5658 
                                                let _v5655 = v5659 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v5660 : string = "Err($0)"
                                                let v5661 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5652 v5660 
                                                let _v5655 = v5661 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v5662 : Result<std_path_PathBuf, std_io_Error> = v5652 |> Error
                                                let _v5655 = v5662 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v5663 : Result<std_path_PathBuf, std_io_Error> = v5652 |> Error
                                                let _v5655 = v5663 
                                                #endif
#else
                                                let v5664 : Result<std_path_PathBuf, std_io_Error> = v5652 |> Error
                                                let _v5655 = v5664 
                                                #endif
                                                let v5665 : Result<std_path_PathBuf, std_io_Error> = _v5655 
                                                v5665
                                        | _ ->
                                            let v5669 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v3050} / path': {v3014} / name: {v3051}"
                                            let v5670 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v5671 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v5672 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5669 v5671 
                                            let _v5670 = v5672 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v5673 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v5674 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5669 v5673 
                                            let _v5670 = v5674 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v5675 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v5676 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5669 v5675 
                                            let _v5670 = v5676 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v5677 : std_io_Error = v5669 
                                            let _v5670 = v5677 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v5678 : std_io_Error = v5669 
                                            let _v5670 = v5678 
                                            #endif
#else
                                            let v5679 : std_io_Error = v5669 
                                            let _v5670 = v5679 
                                            #endif
                                            let v5680 : std_io_Error = _v5670 
                                            let v5683 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v5684 : string = "Err($0)"
                                            let v5685 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5680 v5684 
                                            let _v5683 = v5685 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v5686 : string = "Err($0)"
                                            let v5687 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5680 v5686 
                                            let _v5683 = v5687 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v5688 : string = "Err($0)"
                                            let v5689 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5680 v5688 
                                            let _v5683 = v5689 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v5690 : Result<std_path_PathBuf, std_io_Error> = v5680 |> Error
                                            let _v5683 = v5690 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v5691 : Result<std_path_PathBuf, std_io_Error> = v5680 |> Error
                                            let _v5683 = v5691 
                                            #endif
#else
                                            let v5692 : Result<std_path_PathBuf, std_io_Error> = v5680 |> Error
                                            let _v5683 = v5692 
                                            #endif
                                            let v5693 : Result<std_path_PathBuf, std_io_Error> = _v5683 
                                            v5693
                                    | US13_0(v3036) -> (* Ok *)
                                        let v3037 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v3038 : string = "Ok($0)"
                                        let v3039 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3036 v3038 
                                        let _v3037 = v3039 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v3040 : string = "Ok($0)"
                                        let v3041 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3036 v3040 
                                        let _v3037 = v3041 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v3042 : string = "Ok($0)"
                                        let v3043 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v3036 v3042 
                                        let _v3037 = v3043 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v3044 : Result<std_path_PathBuf, std_io_Error> = v3036 |> Ok
                                        let _v3037 = v3044 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v3045 : Result<std_path_PathBuf, std_io_Error> = v3036 |> Ok
                                        let _v3037 = v3045 
                                        #endif
#else
                                        let v3046 : Result<std_path_PathBuf, std_io_Error> = v3036 |> Ok
                                        let _v3037 = v3046 
                                        #endif
                                        let v3047 : Result<std_path_PathBuf, std_io_Error> = _v3037 
                                        v3047
                                let v5699 : (std_io_Error -> string) = method76()
                                let v5700 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5701 : string = "$0.map_err(|x| $1(x))"
                                let v5702 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5698, v5699) v5701 
                                let _v5700 = v5702 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5703 : string = "$0.map_err(|x| $1(x))"
                                let v5704 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5698, v5699) v5703 
                                let _v5700 = v5704 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5705 : string = "$0.map_err(|x| $1(x))"
                                let v5706 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5698, v5699) v5705 
                                let _v5700 = v5706 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5707 : Result<std_path_PathBuf, string> = match v5698 with Ok x -> Ok x | Error x -> Error (v5699 x)
                                let _v5700 = v5707 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5708 : Result<std_path_PathBuf, string> = match v5698 with Ok x -> Ok x | Error x -> Error (v5699 x)
                                let _v5700 = v5708 
                                #endif
#else
                                let v5709 : Result<std_path_PathBuf, string> = match v5698 with Ok x -> Ok x | Error x -> Error (v5699 x)
                                let _v5700 = v5709 
                                #endif
                                let v5710 : Result<std_path_PathBuf, string> = _v5700 
                                let v5713 : US13 = match v5710 with Ok x -> v2977 x | Error x -> v2978 x
                                match v5713 with
                                | US13_1(v5816) -> (* Error *)
                                    let v5817 : string = $"file_system.read_link / error': {v5816} / error: {v2994} / name: {v2995}"
                                    let v5818 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v5819 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v5820 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5817 v5819 
                                    let _v5818 = v5820 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v5821 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v5822 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5817 v5821 
                                    let _v5818 = v5822 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v5823 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v5824 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5817 v5823 
                                    let _v5818 = v5824 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v5825 : std_io_Error = v5817 
                                    let _v5818 = v5825 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v5826 : std_io_Error = v5817 
                                    let _v5818 = v5826 
                                    #endif
#else
                                    let v5827 : std_io_Error = v5817 
                                    let _v5818 = v5827 
                                    #endif
                                    let v5828 : std_io_Error = _v5818 
                                    let v5831 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v5832 : string = "Err($0)"
                                    let v5833 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5828 v5832 
                                    let _v5831 = v5833 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v5834 : string = "Err($0)"
                                    let v5835 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5828 v5834 
                                    let _v5831 = v5835 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v5836 : string = "Err($0)"
                                    let v5837 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5828 v5836 
                                    let _v5831 = v5837 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v5838 : Result<std_path_PathBuf, std_io_Error> = v5828 |> Error
                                    let _v5831 = v5838 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v5839 : Result<std_path_PathBuf, std_io_Error> = v5828 |> Error
                                    let _v5831 = v5839 
                                    #endif
#else
                                    let v5840 : Result<std_path_PathBuf, std_io_Error> = v5828 |> Error
                                    let _v5831 = v5840 
                                    #endif
                                    let v5841 : Result<std_path_PathBuf, std_io_Error> = _v5831 
                                    v5841
                                | US13_0(v5714) -> (* Ok *)
                                    let v5715 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v5716 : string = "$0.display()"
                                    let v5717 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5714 v5716 
                                    let _v5715 = v5717 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v5718 : string = "$0.display()"
                                    let v5719 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5714 v5718 
                                    let _v5715 = v5719 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v5720 : string = "$0.display()"
                                    let v5721 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v5714 v5720 
                                    let _v5715 = v5721 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v5722 : std_path_Display = v5714 |> unbox<std_path_Display>
                                    let _v5715 = v5722 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v5725 : std_path_Display = v5714 |> unbox<std_path_Display>
                                    let _v5715 = v5725 
                                    #endif
#else
                                    let v5728 : std_path_Display = v5714 |> unbox<std_path_Display>
                                    let _v5715 = v5728 
                                    #endif
                                    let v5731 : std_path_Display = _v5715 
                                    let v5736 : string = v5731 |> string 
                                    let v5739 : string = method56(v5736, v2995)
                                    let v5740 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v5741 : string = "&*$0"
                                    let v5742 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5739 v5741 
                                    let _v5740 = v5742 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v5743 : string = "&*$0"
                                    let v5744 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5739 v5743 
                                    let _v5740 = v5744 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v5745 : string = "&*$0"
                                    let v5746 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v5739 v5745 
                                    let _v5740 = v5746 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v5747 : Ref<Str> = v5739 |> unbox<Ref<Str>>
                                    let _v5740 = v5747 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v5750 : Ref<Str> = v5739 |> unbox<Ref<Str>>
                                    let _v5740 = v5750 
                                    #endif
#else
                                    let v5753 : Ref<Str> = v5739 |> unbox<Ref<Str>>
                                    let _v5740 = v5753 
                                    #endif
                                    let v5756 : Ref<Str> = _v5740 
                                    let v5761 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v5762 : string = "String::from($0)"
                                    let v5763 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5756 v5762 
                                    let _v5761 = v5763 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v5764 : string = "String::from($0)"
                                    let v5765 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5756 v5764 
                                    let _v5761 = v5765 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v5766 : string = "String::from($0)"
                                    let v5767 : std_string_String = Fable.Core.RustInterop.emitRustExpr v5756 v5766 
                                    let _v5761 = v5767 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v5768 : std_string_String = v5756 |> unbox<std_string_String>
                                    let _v5761 = v5768 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v5771 : std_string_String = v5756 |> unbox<std_string_String>
                                    let _v5761 = v5771 
                                    #endif
#else
                                    let v5774 : std_string_String = v5756 |> unbox<std_string_String>
                                    let _v5761 = v5774 
                                    #endif
                                    let v5777 : std_string_String = _v5761 
                                    let v5782 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v5783 : string = "std::path::PathBuf::from($0)"
                                    let v5784 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5777 v5783 
                                    let _v5782 = v5784 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v5785 : string = "std::path::PathBuf::from($0)"
                                    let v5786 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5777 v5785 
                                    let _v5782 = v5786 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v5787 : string = "std::path::PathBuf::from($0)"
                                    let v5788 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v5777 v5787 
                                    let _v5782 = v5788 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v5789 : std_path_PathBuf = v5777 |> std_path_PathBuf 
                                    let _v5782 = v5789 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v5792 : std_path_PathBuf = v5777 |> std_path_PathBuf 
                                    let _v5782 = v5792 
                                    #endif
#else
                                    let v5795 : std_path_PathBuf = v5777 |> std_path_PathBuf 
                                    let _v5782 = v5795 
                                    #endif
                                    let v5798 : std_path_PathBuf = _v5782 
                                    let v5803 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v5804 : string = "Ok($0)"
                                    let v5805 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5798 v5804 
                                    let _v5803 = v5805 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v5806 : string = "Ok($0)"
                                    let v5807 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5798 v5806 
                                    let _v5803 = v5807 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v5808 : string = "Ok($0)"
                                    let v5809 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5798 v5808 
                                    let _v5803 = v5809 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v5810 : Result<std_path_PathBuf, std_io_Error> = v5798 |> Ok
                                    let _v5803 = v5810 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v5811 : Result<std_path_PathBuf, std_io_Error> = v5798 |> Ok
                                    let _v5803 = v5811 
                                    #endif
#else
                                    let v5812 : Result<std_path_PathBuf, std_io_Error> = v5798 |> Ok
                                    let _v5803 = v5812 
                                    #endif
                                    let v5813 : Result<std_path_PathBuf, std_io_Error> = _v5803 
                                    v5813
                            else
                                let v5846 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v2994} / path': {v1} / name: {v2995}"
                                let v5847 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5848 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v5849 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5846 v5848 
                                let _v5847 = v5849 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5850 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v5851 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5846 v5850 
                                let _v5847 = v5851 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5852 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v5853 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5846 v5852 
                                let _v5847 = v5853 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5854 : std_io_Error = v5846 
                                let _v5847 = v5854 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5855 : std_io_Error = v5846 
                                let _v5847 = v5855 
                                #endif
#else
                                let v5856 : std_io_Error = v5846 
                                let _v5847 = v5856 
                                #endif
                                let v5857 : std_io_Error = _v5847 
                                let v5860 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5861 : string = "Err($0)"
                                let v5862 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5857 v5861 
                                let _v5860 = v5862 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5863 : string = "Err($0)"
                                let v5864 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5857 v5863 
                                let _v5860 = v5864 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5865 : string = "Err($0)"
                                let v5866 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5857 v5865 
                                let _v5860 = v5866 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5867 : Result<std_path_PathBuf, std_io_Error> = v5857 |> Error
                                let _v5860 = v5867 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5868 : Result<std_path_PathBuf, std_io_Error> = v5857 |> Error
                                let _v5860 = v5868 
                                #endif
#else
                                let v5869 : Result<std_path_PathBuf, std_io_Error> = v5857 |> Error
                                let _v5860 = v5869 
                                #endif
                                let v5870 : Result<std_path_PathBuf, std_io_Error> = _v5860 
                                v5870
                        | _ ->
                            let v5874 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v2994} / path': {v1} / name: {v2995}"
                            let v5875 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v5876 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v5877 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5874 v5876 
                            let _v5875 = v5877 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v5878 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v5879 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5874 v5878 
                            let _v5875 = v5879 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v5880 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v5881 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v5874 v5880 
                            let _v5875 = v5881 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v5882 : std_io_Error = v5874 
                            let _v5875 = v5882 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v5883 : std_io_Error = v5874 
                            let _v5875 = v5883 
                            #endif
#else
                            let v5884 : std_io_Error = v5874 
                            let _v5875 = v5884 
                            #endif
                            let v5885 : std_io_Error = _v5875 
                            let v5888 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v5889 : string = "Err($0)"
                            let v5890 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5885 v5889 
                            let _v5888 = v5890 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v5891 : string = "Err($0)"
                            let v5892 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5885 v5891 
                            let _v5888 = v5892 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v5893 : string = "Err($0)"
                            let v5894 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5885 v5893 
                            let _v5888 = v5894 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v5895 : Result<std_path_PathBuf, std_io_Error> = v5885 |> Error
                            let _v5888 = v5895 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v5896 : Result<std_path_PathBuf, std_io_Error> = v5885 |> Error
                            let _v5888 = v5896 
                            #endif
#else
                            let v5897 : Result<std_path_PathBuf, std_io_Error> = v5885 |> Error
                            let _v5888 = v5897 
                            #endif
                            let v5898 : Result<std_path_PathBuf, std_io_Error> = _v5888 
                            v5898
                    | US13_0(v2980) -> (* Ok *)
                        let v2981 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v2982 : string = "Ok($0)"
                        let v2983 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2980 v2982 
                        let _v2981 = v2983 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v2984 : string = "Ok($0)"
                        let v2985 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2980 v2984 
                        let _v2981 = v2985 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v2986 : string = "Ok($0)"
                        let v2987 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v2980 v2986 
                        let _v2981 = v2987 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v2988 : Result<std_path_PathBuf, std_io_Error> = v2980 |> Ok
                        let _v2981 = v2988 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v2989 : Result<std_path_PathBuf, std_io_Error> = v2980 |> Ok
                        let _v2981 = v2989 
                        #endif
#else
                        let v2990 : Result<std_path_PathBuf, std_io_Error> = v2980 |> Ok
                        let _v2981 = v2990 
                        #endif
                        let v2991 : Result<std_path_PathBuf, std_io_Error> = _v2981 
                        v2991
            let _v10 = v5904 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v5905 : bool = method9(v1)
            let v8851 : Result<std_path_PathBuf, std_io_Error> =
                if v5905 then
                    let v5906 : string = "std::fs::read_link(&*$0)"
                    let v5907 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1 v5906 
                    v5907
                else
                    let v5908 : string = "std::fs::read_link(&*$0)"
                    let v5909 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v1 v5908 
                    let v5910 : (std_io_Error -> string) = method76()
                    let v5911 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v5912 : string = "$0.map_err(|x| $1(x))"
                    let v5913 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5909, v5910) v5912 
                    let _v5911 = v5913 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v5914 : string = "$0.map_err(|x| $1(x))"
                    let v5915 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5909, v5910) v5914 
                    let _v5911 = v5915 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v5916 : string = "$0.map_err(|x| $1(x))"
                    let v5917 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5909, v5910) v5916 
                    let _v5911 = v5917 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v5918 : Result<std_path_PathBuf, string> = match v5909 with Ok x -> Ok x | Error x -> Error (v5910 x)
                    let _v5911 = v5918 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v5919 : Result<std_path_PathBuf, string> = match v5909 with Ok x -> Ok x | Error x -> Error (v5910 x)
                    let _v5911 = v5919 
                    #endif
#else
                    let v5920 : Result<std_path_PathBuf, string> = match v5909 with Ok x -> Ok x | Error x -> Error (v5910 x)
                    let _v5911 = v5920 
                    #endif
                    let v5921 : Result<std_path_PathBuf, string> = _v5911 
                    let v5924 : (std_path_PathBuf -> US13) = closure47()
                    let v5925 : (string -> US13) = closure48()
                    let v5926 : US13 = match v5921 with Ok x -> v5924 x | Error x -> v5925 x
                    match v5926 with
                    | US13_1(v5941) -> (* Error *)
                        let v5942 : string = method19(v1)
                        let v5943 : string option = method78(v1)
                        let v5944 : (string -> US1) = method4()
                        let v5945 : US1 option = v5943 |> Option.map v5944 
                        let v5956 : US1 = US1_1
                        let v5957 : US1 = v5945 |> Option.defaultValue v5956 
                        match v5957 with
                        | US1_0(v5961) -> (* Some *)
                            let v5962 : string = ""
                            let v5963 : bool = v1 <> v5962 
                            if v5963 then
                                let v5966 : string = "std::fs::read_link(&*$0)"
                                let v5967 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5961 v5966 
                                let v5968 : (std_io_Error -> string) = method76()
                                let v5969 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v5970 : string = "$0.map_err(|x| $1(x))"
                                let v5971 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5967, v5968) v5970 
                                let _v5969 = v5971 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v5972 : string = "$0.map_err(|x| $1(x))"
                                let v5973 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5967, v5968) v5972 
                                let _v5969 = v5973 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v5974 : string = "$0.map_err(|x| $1(x))"
                                let v5975 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v5967, v5968) v5974 
                                let _v5969 = v5975 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v5976 : Result<std_path_PathBuf, string> = match v5967 with Ok x -> Ok x | Error x -> Error (v5968 x)
                                let _v5969 = v5976 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v5977 : Result<std_path_PathBuf, string> = match v5967 with Ok x -> Ok x | Error x -> Error (v5968 x)
                                let _v5969 = v5977 
                                #endif
#else
                                let v5978 : Result<std_path_PathBuf, string> = match v5967 with Ok x -> Ok x | Error x -> Error (v5968 x)
                                let _v5969 = v5978 
                                #endif
                                let v5979 : Result<std_path_PathBuf, string> = _v5969 
                                let v5982 : US13 = match v5979 with Ok x -> v5924 x | Error x -> v5925 x
                                let v8645 : Result<std_path_PathBuf, std_io_Error> =
                                    match v5982 with
                                    | US13_1(v5997) -> (* Error *)
                                        let v5998 : string = method19(v5961)
                                        let v5999 : string option = method78(v5961)
                                        let v6000 : (string -> US1) = method4()
                                        let v6001 : US1 option = v5999 |> Option.map v6000 
                                        let v6012 : US1 = US1_1
                                        let v6013 : US1 = v6001 |> Option.defaultValue v6012 
                                        match v6013 with
                                        | US1_0(v6017) -> (* Some *)
                                            let v6018 : bool = v5961 <> v5962 
                                            if v6018 then
                                                let v6021 : string = "std::fs::read_link(&*$0)"
                                                let v6022 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6017 v6021 
                                                let v6023 : (std_io_Error -> string) = method76()
                                                let v6024 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v6025 : string = "$0.map_err(|x| $1(x))"
                                                let v6026 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6022, v6023) v6025 
                                                let _v6024 = v6026 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v6027 : string = "$0.map_err(|x| $1(x))"
                                                let v6028 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6022, v6023) v6027 
                                                let _v6024 = v6028 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v6029 : string = "$0.map_err(|x| $1(x))"
                                                let v6030 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6022, v6023) v6029 
                                                let _v6024 = v6030 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v6031 : Result<std_path_PathBuf, string> = match v6022 with Ok x -> Ok x | Error x -> Error (v6023 x)
                                                let _v6024 = v6031 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v6032 : Result<std_path_PathBuf, string> = match v6022 with Ok x -> Ok x | Error x -> Error (v6023 x)
                                                let _v6024 = v6032 
                                                #endif
#else
                                                let v6033 : Result<std_path_PathBuf, string> = match v6022 with Ok x -> Ok x | Error x -> Error (v6023 x)
                                                let _v6024 = v6033 
                                                #endif
                                                let v6034 : Result<std_path_PathBuf, string> = _v6024 
                                                let v6037 : US13 = match v6034 with Ok x -> v5924 x | Error x -> v5925 x
                                                let v8440 : Result<std_path_PathBuf, std_io_Error> =
                                                    match v6037 with
                                                    | US13_1(v6052) -> (* Error *)
                                                        let v6053 : string = method19(v6017)
                                                        let v6054 : string option = method78(v6017)
                                                        let v6055 : (string -> US1) = method4()
                                                        let v6056 : US1 option = v6054 |> Option.map v6055 
                                                        let v6067 : US1 = US1_1
                                                        let v6068 : US1 = v6056 |> Option.defaultValue v6067 
                                                        match v6068 with
                                                        | US1_0(v6072) -> (* Some *)
                                                            let v6073 : bool = v6017 <> v5962 
                                                            if v6073 then
                                                                let v6076 : string = "std::fs::read_link(&*$0)"
                                                                let v6077 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6072 v6076 
                                                                let v6078 : (std_io_Error -> string) = method76()
                                                                let v6079 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v6080 : string = "$0.map_err(|x| $1(x))"
                                                                let v6081 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6077, v6078) v6080 
                                                                let _v6079 = v6081 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v6082 : string = "$0.map_err(|x| $1(x))"
                                                                let v6083 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6077, v6078) v6082 
                                                                let _v6079 = v6083 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v6084 : string = "$0.map_err(|x| $1(x))"
                                                                let v6085 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6077, v6078) v6084 
                                                                let _v6079 = v6085 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v6086 : Result<std_path_PathBuf, string> = match v6077 with Ok x -> Ok x | Error x -> Error (v6078 x)
                                                                let _v6079 = v6086 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v6087 : Result<std_path_PathBuf, string> = match v6077 with Ok x -> Ok x | Error x -> Error (v6078 x)
                                                                let _v6079 = v6087 
                                                                #endif
#else
                                                                let v6088 : Result<std_path_PathBuf, string> = match v6077 with Ok x -> Ok x | Error x -> Error (v6078 x)
                                                                let _v6079 = v6088 
                                                                #endif
                                                                let v6089 : Result<std_path_PathBuf, string> = _v6079 
                                                                let v6092 : US13 = match v6089 with Ok x -> v5924 x | Error x -> v5925 x
                                                                let v8235 : Result<std_path_PathBuf, std_io_Error> =
                                                                    match v6092 with
                                                                    | US13_1(v6107) -> (* Error *)
                                                                        let v6108 : string = method19(v6072)
                                                                        let v6109 : string option = method78(v6072)
                                                                        let v6110 : (string -> US1) = method4()
                                                                        let v6111 : US1 option = v6109 |> Option.map v6110 
                                                                        let v6122 : US1 = US1_1
                                                                        let v6123 : US1 = v6111 |> Option.defaultValue v6122 
                                                                        match v6123 with
                                                                        | US1_0(v6127) -> (* Some *)
                                                                            let v6128 : bool = v6072 <> v5962 
                                                                            if v6128 then
                                                                                let v6131 : string = "std::fs::read_link(&*$0)"
                                                                                let v6132 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6127 v6131 
                                                                                let v6133 : (std_io_Error -> string) = method76()
                                                                                let v6134 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v6135 : string = "$0.map_err(|x| $1(x))"
                                                                                let v6136 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6132, v6133) v6135 
                                                                                let _v6134 = v6136 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v6137 : string = "$0.map_err(|x| $1(x))"
                                                                                let v6138 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6132, v6133) v6137 
                                                                                let _v6134 = v6138 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v6139 : string = "$0.map_err(|x| $1(x))"
                                                                                let v6140 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6132, v6133) v6139 
                                                                                let _v6134 = v6140 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v6141 : Result<std_path_PathBuf, string> = match v6132 with Ok x -> Ok x | Error x -> Error (v6133 x)
                                                                                let _v6134 = v6141 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v6142 : Result<std_path_PathBuf, string> = match v6132 with Ok x -> Ok x | Error x -> Error (v6133 x)
                                                                                let _v6134 = v6142 
                                                                                #endif
#else
                                                                                let v6143 : Result<std_path_PathBuf, string> = match v6132 with Ok x -> Ok x | Error x -> Error (v6133 x)
                                                                                let _v6134 = v6143 
                                                                                #endif
                                                                                let v6144 : Result<std_path_PathBuf, string> = _v6134 
                                                                                let v6147 : US13 = match v6144 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                let v8030 : Result<std_path_PathBuf, std_io_Error> =
                                                                                    match v6147 with
                                                                                    | US13_1(v6162) -> (* Error *)
                                                                                        let v6163 : string = method19(v6127)
                                                                                        let v6164 : string option = method78(v6127)
                                                                                        let v6165 : (string -> US1) = method4()
                                                                                        let v6166 : US1 option = v6164 |> Option.map v6165 
                                                                                        let v6177 : US1 = US1_1
                                                                                        let v6178 : US1 = v6166 |> Option.defaultValue v6177 
                                                                                        match v6178 with
                                                                                        | US1_0(v6182) -> (* Some *)
                                                                                            let v6183 : bool = v6127 <> v5962 
                                                                                            if v6183 then
                                                                                                let v6186 : string = "std::fs::read_link(&*$0)"
                                                                                                let v6187 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6182 v6186 
                                                                                                let v6188 : (std_io_Error -> string) = method76()
                                                                                                let v6189 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v6190 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v6191 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6187, v6188) v6190 
                                                                                                let _v6189 = v6191 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v6192 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v6193 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6187, v6188) v6192 
                                                                                                let _v6189 = v6193 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v6194 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v6195 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6187, v6188) v6194 
                                                                                                let _v6189 = v6195 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v6196 : Result<std_path_PathBuf, string> = match v6187 with Ok x -> Ok x | Error x -> Error (v6188 x)
                                                                                                let _v6189 = v6196 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v6197 : Result<std_path_PathBuf, string> = match v6187 with Ok x -> Ok x | Error x -> Error (v6188 x)
                                                                                                let _v6189 = v6197 
                                                                                                #endif
#else
                                                                                                let v6198 : Result<std_path_PathBuf, string> = match v6187 with Ok x -> Ok x | Error x -> Error (v6188 x)
                                                                                                let _v6189 = v6198 
                                                                                                #endif
                                                                                                let v6199 : Result<std_path_PathBuf, string> = _v6189 
                                                                                                let v6202 : US13 = match v6199 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                let v7825 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                    match v6202 with
                                                                                                    | US13_1(v6217) -> (* Error *)
                                                                                                        let v6218 : string = method19(v6182)
                                                                                                        let v6219 : string option = method78(v6182)
                                                                                                        let v6220 : (string -> US1) = method4()
                                                                                                        let v6221 : US1 option = v6219 |> Option.map v6220 
                                                                                                        let v6232 : US1 = US1_1
                                                                                                        let v6233 : US1 = v6221 |> Option.defaultValue v6232 
                                                                                                        match v6233 with
                                                                                                        | US1_0(v6237) -> (* Some *)
                                                                                                            let v6238 : bool = v6182 <> v5962 
                                                                                                            if v6238 then
                                                                                                                let v6241 : string = "std::fs::read_link(&*$0)"
                                                                                                                let v6242 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6237 v6241 
                                                                                                                let v6243 : (std_io_Error -> string) = method76()
                                                                                                                let v6244 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v6245 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v6246 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6242, v6243) v6245 
                                                                                                                let _v6244 = v6246 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v6247 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v6248 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6242, v6243) v6247 
                                                                                                                let _v6244 = v6248 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v6249 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v6250 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6242, v6243) v6249 
                                                                                                                let _v6244 = v6250 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v6251 : Result<std_path_PathBuf, string> = match v6242 with Ok x -> Ok x | Error x -> Error (v6243 x)
                                                                                                                let _v6244 = v6251 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v6252 : Result<std_path_PathBuf, string> = match v6242 with Ok x -> Ok x | Error x -> Error (v6243 x)
                                                                                                                let _v6244 = v6252 
                                                                                                                #endif
#else
                                                                                                                let v6253 : Result<std_path_PathBuf, string> = match v6242 with Ok x -> Ok x | Error x -> Error (v6243 x)
                                                                                                                let _v6244 = v6253 
                                                                                                                #endif
                                                                                                                let v6254 : Result<std_path_PathBuf, string> = _v6244 
                                                                                                                let v6257 : US13 = match v6254 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                let v7620 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                    match v6257 with
                                                                                                                    | US13_1(v6272) -> (* Error *)
                                                                                                                        let v6273 : string = method19(v6237)
                                                                                                                        let v6274 : string option = method78(v6237)
                                                                                                                        let v6275 : (string -> US1) = method4()
                                                                                                                        let v6276 : US1 option = v6274 |> Option.map v6275 
                                                                                                                        let v6287 : US1 = US1_1
                                                                                                                        let v6288 : US1 = v6276 |> Option.defaultValue v6287 
                                                                                                                        match v6288 with
                                                                                                                        | US1_0(v6292) -> (* Some *)
                                                                                                                            let v6293 : bool = v6237 <> v5962 
                                                                                                                            if v6293 then
                                                                                                                                let v6296 : string = "std::fs::read_link(&*$0)"
                                                                                                                                let v6297 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6292 v6296 
                                                                                                                                let v6298 : (std_io_Error -> string) = method76()
                                                                                                                                let v6299 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v6300 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v6301 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6297, v6298) v6300 
                                                                                                                                let _v6299 = v6301 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v6302 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v6303 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6297, v6298) v6302 
                                                                                                                                let _v6299 = v6303 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v6304 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v6305 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6297, v6298) v6304 
                                                                                                                                let _v6299 = v6305 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v6306 : Result<std_path_PathBuf, string> = match v6297 with Ok x -> Ok x | Error x -> Error (v6298 x)
                                                                                                                                let _v6299 = v6306 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v6307 : Result<std_path_PathBuf, string> = match v6297 with Ok x -> Ok x | Error x -> Error (v6298 x)
                                                                                                                                let _v6299 = v6307 
                                                                                                                                #endif
#else
                                                                                                                                let v6308 : Result<std_path_PathBuf, string> = match v6297 with Ok x -> Ok x | Error x -> Error (v6298 x)
                                                                                                                                let _v6299 = v6308 
                                                                                                                                #endif
                                                                                                                                let v6309 : Result<std_path_PathBuf, string> = _v6299 
                                                                                                                                let v6312 : US13 = match v6309 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                let v7415 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                    match v6312 with
                                                                                                                                    | US13_1(v6327) -> (* Error *)
                                                                                                                                        let v6328 : string = method19(v6292)
                                                                                                                                        let v6329 : string option = method78(v6292)
                                                                                                                                        let v6330 : (string -> US1) = method4()
                                                                                                                                        let v6331 : US1 option = v6329 |> Option.map v6330 
                                                                                                                                        let v6342 : US1 = US1_1
                                                                                                                                        let v6343 : US1 = v6331 |> Option.defaultValue v6342 
                                                                                                                                        match v6343 with
                                                                                                                                        | US1_0(v6347) -> (* Some *)
                                                                                                                                            let v6348 : bool = v6292 <> v5962 
                                                                                                                                            if v6348 then
                                                                                                                                                let v6351 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                let v6352 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6347 v6351 
                                                                                                                                                let v6353 : (std_io_Error -> string) = method76()
                                                                                                                                                let v6354 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v6355 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v6356 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6352, v6353) v6355 
                                                                                                                                                let _v6354 = v6356 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v6357 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v6358 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6352, v6353) v6357 
                                                                                                                                                let _v6354 = v6358 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v6359 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v6360 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6352, v6353) v6359 
                                                                                                                                                let _v6354 = v6360 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v6361 : Result<std_path_PathBuf, string> = match v6352 with Ok x -> Ok x | Error x -> Error (v6353 x)
                                                                                                                                                let _v6354 = v6361 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v6362 : Result<std_path_PathBuf, string> = match v6352 with Ok x -> Ok x | Error x -> Error (v6353 x)
                                                                                                                                                let _v6354 = v6362 
                                                                                                                                                #endif
#else
                                                                                                                                                let v6363 : Result<std_path_PathBuf, string> = match v6352 with Ok x -> Ok x | Error x -> Error (v6353 x)
                                                                                                                                                let _v6354 = v6363 
                                                                                                                                                #endif
                                                                                                                                                let v6364 : Result<std_path_PathBuf, string> = _v6354 
                                                                                                                                                let v6367 : US13 = match v6364 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                                let v7210 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                    match v6367 with
                                                                                                                                                    | US13_1(v6382) -> (* Error *)
                                                                                                                                                        let v6383 : string = method19(v6347)
                                                                                                                                                        let v6384 : string option = method78(v6347)
                                                                                                                                                        let v6385 : (string -> US1) = method4()
                                                                                                                                                        let v6386 : US1 option = v6384 |> Option.map v6385 
                                                                                                                                                        let v6397 : US1 = US1_1
                                                                                                                                                        let v6398 : US1 = v6386 |> Option.defaultValue v6397 
                                                                                                                                                        match v6398 with
                                                                                                                                                        | US1_0(v6402) -> (* Some *)
                                                                                                                                                            let v6403 : bool = v6347 <> v5962 
                                                                                                                                                            if v6403 then
                                                                                                                                                                let v6406 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                let v6407 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6402 v6406 
                                                                                                                                                                let v6408 : (std_io_Error -> string) = method76()
                                                                                                                                                                let v6409 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v6410 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v6411 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6407, v6408) v6410 
                                                                                                                                                                let _v6409 = v6411 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v6412 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v6413 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6407, v6408) v6412 
                                                                                                                                                                let _v6409 = v6413 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v6414 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v6415 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6407, v6408) v6414 
                                                                                                                                                                let _v6409 = v6415 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v6416 : Result<std_path_PathBuf, string> = match v6407 with Ok x -> Ok x | Error x -> Error (v6408 x)
                                                                                                                                                                let _v6409 = v6416 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v6417 : Result<std_path_PathBuf, string> = match v6407 with Ok x -> Ok x | Error x -> Error (v6408 x)
                                                                                                                                                                let _v6409 = v6417 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v6418 : Result<std_path_PathBuf, string> = match v6407 with Ok x -> Ok x | Error x -> Error (v6408 x)
                                                                                                                                                                let _v6409 = v6418 
                                                                                                                                                                #endif
                                                                                                                                                                let v6419 : Result<std_path_PathBuf, string> = _v6409 
                                                                                                                                                                let v6422 : US13 = match v6419 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                                                let v7005 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                    match v6422 with
                                                                                                                                                                    | US13_1(v6437) -> (* Error *)
                                                                                                                                                                        let v6438 : string = method19(v6402)
                                                                                                                                                                        let v6439 : string option = method78(v6402)
                                                                                                                                                                        let v6440 : (string -> US1) = method4()
                                                                                                                                                                        let v6441 : US1 option = v6439 |> Option.map v6440 
                                                                                                                                                                        let v6452 : US1 = US1_1
                                                                                                                                                                        let v6453 : US1 = v6441 |> Option.defaultValue v6452 
                                                                                                                                                                        match v6453 with
                                                                                                                                                                        | US1_0(v6457) -> (* Some *)
                                                                                                                                                                            let v6458 : bool = v6402 <> v5962 
                                                                                                                                                                            if v6458 then
                                                                                                                                                                                let v6461 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                let v6462 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6457 v6461 
                                                                                                                                                                                let v6463 : (std_io_Error -> string) = method76()
                                                                                                                                                                                let v6464 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6465 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v6466 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6462, v6463) v6465 
                                                                                                                                                                                let _v6464 = v6466 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6467 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v6468 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6462, v6463) v6467 
                                                                                                                                                                                let _v6464 = v6468 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6469 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v6470 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6462, v6463) v6469 
                                                                                                                                                                                let _v6464 = v6470 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6471 : Result<std_path_PathBuf, string> = match v6462 with Ok x -> Ok x | Error x -> Error (v6463 x)
                                                                                                                                                                                let _v6464 = v6471 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6472 : Result<std_path_PathBuf, string> = match v6462 with Ok x -> Ok x | Error x -> Error (v6463 x)
                                                                                                                                                                                let _v6464 = v6472 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6473 : Result<std_path_PathBuf, string> = match v6462 with Ok x -> Ok x | Error x -> Error (v6463 x)
                                                                                                                                                                                let _v6464 = v6473 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6474 : Result<std_path_PathBuf, string> = _v6464 
                                                                                                                                                                                let v6477 : US13 = match v6474 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                                                                let v6800 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                    match v6477 with
                                                                                                                                                                                    | US13_1(v6492) -> (* Error *)
                                                                                                                                                                                        let v6493 : string = method19(v6457)
                                                                                                                                                                                        let v6494 : string option = method78(v6457)
                                                                                                                                                                                        let v6495 : (string -> US1) = method4()
                                                                                                                                                                                        let v6496 : US1 option = v6494 |> Option.map v6495 
                                                                                                                                                                                        let v6507 : US1 = US1_1
                                                                                                                                                                                        let v6508 : US1 = v6496 |> Option.defaultValue v6507 
                                                                                                                                                                                        match v6508 with
                                                                                                                                                                                        | US1_0(v6512) -> (* Some *)
                                                                                                                                                                                            let v6513 : bool = v6457 <> v5962 
                                                                                                                                                                                            if v6513 then
                                                                                                                                                                                                let v6516 : string = "std::fs::read_link(&*$0)"
                                                                                                                                                                                                let v6517 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6512 v6516 
                                                                                                                                                                                                let v6518 : (std_io_Error -> string) = method76()
                                                                                                                                                                                                let v6519 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6520 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v6521 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6517, v6518) v6520 
                                                                                                                                                                                                let _v6519 = v6521 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6522 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v6523 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6517, v6518) v6522 
                                                                                                                                                                                                let _v6519 = v6523 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6524 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v6525 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6517, v6518) v6524 
                                                                                                                                                                                                let _v6519 = v6525 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6526 : Result<std_path_PathBuf, string> = match v6517 with Ok x -> Ok x | Error x -> Error (v6518 x)
                                                                                                                                                                                                let _v6519 = v6526 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6527 : Result<std_path_PathBuf, string> = match v6517 with Ok x -> Ok x | Error x -> Error (v6518 x)
                                                                                                                                                                                                let _v6519 = v6527 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6528 : Result<std_path_PathBuf, string> = match v6517 with Ok x -> Ok x | Error x -> Error (v6518 x)
                                                                                                                                                                                                let _v6519 = v6528 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6529 : Result<std_path_PathBuf, string> = _v6519 
                                                                                                                                                                                                let v6532 : US13 = match v6529 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                                                                                let v6595 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                    match v6532 with
                                                                                                                                                                                                    | US13_1(v6547) -> (* Error *)
                                                                                                                                                                                                        let v6548 : string = method19(v6512)
                                                                                                                                                                                                        let v6549 : string option = method78(v6512)
                                                                                                                                                                                                        let v6550 : (string -> US1) = method4()
                                                                                                                                                                                                        let v6551 : US1 option = v6549 |> Option.map v6550 
                                                                                                                                                                                                        let v6562 : US1 = US1_1
                                                                                                                                                                                                        let v6563 : US1 = v6551 |> Option.defaultValue v6562 
                                                                                                                                                                                                        let v6567 : string = $"file_system.read_link / path: {v1} / n: {11uy} / path': {v6512} / name: {v6548}"
                                                                                                                                                                                                        let v6568 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v6569 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v6570 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6567 v6569 
                                                                                                                                                                                                        let _v6568 = v6570 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v6571 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v6572 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6567 v6571 
                                                                                                                                                                                                        let _v6568 = v6572 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v6573 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                        let v6574 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6567 v6573 
                                                                                                                                                                                                        let _v6568 = v6574 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v6575 : std_io_Error = v6567 
                                                                                                                                                                                                        let _v6568 = v6575 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v6576 : std_io_Error = v6567 
                                                                                                                                                                                                        let _v6568 = v6576 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v6577 : std_io_Error = v6567 
                                                                                                                                                                                                        let _v6568 = v6577 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v6578 : std_io_Error = _v6568 
                                                                                                                                                                                                        let v6581 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v6582 : string = "Err($0)"
                                                                                                                                                                                                        let v6583 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6578 v6582 
                                                                                                                                                                                                        let _v6581 = v6583 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v6584 : string = "Err($0)"
                                                                                                                                                                                                        let v6585 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6578 v6584 
                                                                                                                                                                                                        let _v6581 = v6585 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v6586 : string = "Err($0)"
                                                                                                                                                                                                        let v6587 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6578 v6586 
                                                                                                                                                                                                        let _v6581 = v6587 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v6588 : Result<std_path_PathBuf, std_io_Error> = v6578 |> Error
                                                                                                                                                                                                        let _v6581 = v6588 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v6589 : Result<std_path_PathBuf, std_io_Error> = v6578 |> Error
                                                                                                                                                                                                        let _v6581 = v6589 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v6590 : Result<std_path_PathBuf, std_io_Error> = v6578 |> Error
                                                                                                                                                                                                        let _v6581 = v6590 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v6591 : Result<std_path_PathBuf, std_io_Error> = _v6581 
                                                                                                                                                                                                        v6591
                                                                                                                                                                                                    | US13_0(v6533) -> (* Ok *)
                                                                                                                                                                                                        let v6534 : unit = ()
                                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                        let v6535 : string = "Ok($0)"
                                                                                                                                                                                                        let v6536 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6533 v6535 
                                                                                                                                                                                                        let _v6534 = v6536 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                        let v6537 : string = "Ok($0)"
                                                                                                                                                                                                        let v6538 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6533 v6537 
                                                                                                                                                                                                        let _v6534 = v6538 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                        let v6539 : string = "Ok($0)"
                                                                                                                                                                                                        let v6540 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6533 v6539 
                                                                                                                                                                                                        let _v6534 = v6540 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                        let v6541 : Result<std_path_PathBuf, std_io_Error> = v6533 |> Ok
                                                                                                                                                                                                        let _v6534 = v6541 
                                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                        let v6542 : Result<std_path_PathBuf, std_io_Error> = v6533 |> Ok
                                                                                                                                                                                                        let _v6534 = v6542 
                                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                                        let v6543 : Result<std_path_PathBuf, std_io_Error> = v6533 |> Ok
                                                                                                                                                                                                        let _v6534 = v6543 
                                                                                                                                                                                                        #endif
                                                                                                                                                                                                        let v6544 : Result<std_path_PathBuf, std_io_Error> = _v6534 
                                                                                                                                                                                                        v6544
                                                                                                                                                                                                let v6596 : (std_io_Error -> string) = method76()
                                                                                                                                                                                                let v6597 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6598 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v6599 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6595, v6596) v6598 
                                                                                                                                                                                                let _v6597 = v6599 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6600 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v6601 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6595, v6596) v6600 
                                                                                                                                                                                                let _v6597 = v6601 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6602 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                                let v6603 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6595, v6596) v6602 
                                                                                                                                                                                                let _v6597 = v6603 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6604 : Result<std_path_PathBuf, string> = match v6595 with Ok x -> Ok x | Error x -> Error (v6596 x)
                                                                                                                                                                                                let _v6597 = v6604 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6605 : Result<std_path_PathBuf, string> = match v6595 with Ok x -> Ok x | Error x -> Error (v6596 x)
                                                                                                                                                                                                let _v6597 = v6605 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6606 : Result<std_path_PathBuf, string> = match v6595 with Ok x -> Ok x | Error x -> Error (v6596 x)
                                                                                                                                                                                                let _v6597 = v6606 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6607 : Result<std_path_PathBuf, string> = _v6597 
                                                                                                                                                                                                let v6610 : US13 = match v6607 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                                                                                match v6610 with
                                                                                                                                                                                                | US13_1(v6713) -> (* Error *)
                                                                                                                                                                                                    let v6714 : string = $"file_system.read_link / error': {v6713} / error: {v6492} / name: {v6493}"
                                                                                                                                                                                                    let v6715 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6716 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v6717 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6714 v6716 
                                                                                                                                                                                                    let _v6715 = v6717 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6718 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v6719 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6714 v6718 
                                                                                                                                                                                                    let _v6715 = v6719 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6720 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v6721 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6714 v6720 
                                                                                                                                                                                                    let _v6715 = v6721 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6722 : std_io_Error = v6714 
                                                                                                                                                                                                    let _v6715 = v6722 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6723 : std_io_Error = v6714 
                                                                                                                                                                                                    let _v6715 = v6723 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6724 : std_io_Error = v6714 
                                                                                                                                                                                                    let _v6715 = v6724 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6725 : std_io_Error = _v6715 
                                                                                                                                                                                                    let v6728 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6729 : string = "Err($0)"
                                                                                                                                                                                                    let v6730 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6725 v6729 
                                                                                                                                                                                                    let _v6728 = v6730 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6731 : string = "Err($0)"
                                                                                                                                                                                                    let v6732 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6725 v6731 
                                                                                                                                                                                                    let _v6728 = v6732 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6733 : string = "Err($0)"
                                                                                                                                                                                                    let v6734 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6725 v6733 
                                                                                                                                                                                                    let _v6728 = v6734 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6735 : Result<std_path_PathBuf, std_io_Error> = v6725 |> Error
                                                                                                                                                                                                    let _v6728 = v6735 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6736 : Result<std_path_PathBuf, std_io_Error> = v6725 |> Error
                                                                                                                                                                                                    let _v6728 = v6736 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6737 : Result<std_path_PathBuf, std_io_Error> = v6725 |> Error
                                                                                                                                                                                                    let _v6728 = v6737 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6738 : Result<std_path_PathBuf, std_io_Error> = _v6728 
                                                                                                                                                                                                    v6738
                                                                                                                                                                                                | US13_0(v6611) -> (* Ok *)
                                                                                                                                                                                                    let v6612 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6613 : string = "$0.display()"
                                                                                                                                                                                                    let v6614 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6611 v6613 
                                                                                                                                                                                                    let _v6612 = v6614 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6615 : string = "$0.display()"
                                                                                                                                                                                                    let v6616 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6611 v6615 
                                                                                                                                                                                                    let _v6612 = v6616 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6617 : string = "$0.display()"
                                                                                                                                                                                                    let v6618 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6611 v6617 
                                                                                                                                                                                                    let _v6612 = v6618 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6619 : std_path_Display = v6611 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v6612 = v6619 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6622 : std_path_Display = v6611 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v6612 = v6622 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6625 : std_path_Display = v6611 |> unbox<std_path_Display>
                                                                                                                                                                                                    let _v6612 = v6625 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6628 : std_path_Display = _v6612 
                                                                                                                                                                                                    let v6633 : string = v6628 |> string 
                                                                                                                                                                                                    let v6636 : string = method56(v6633, v6493)
                                                                                                                                                                                                    let v6637 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6638 : string = "&*$0"
                                                                                                                                                                                                    let v6639 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6636 v6638 
                                                                                                                                                                                                    let _v6637 = v6639 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6640 : string = "&*$0"
                                                                                                                                                                                                    let v6641 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6636 v6640 
                                                                                                                                                                                                    let _v6637 = v6641 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6642 : string = "&*$0"
                                                                                                                                                                                                    let v6643 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6636 v6642 
                                                                                                                                                                                                    let _v6637 = v6643 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6644 : Ref<Str> = v6636 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v6637 = v6644 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6647 : Ref<Str> = v6636 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v6637 = v6647 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6650 : Ref<Str> = v6636 |> unbox<Ref<Str>>
                                                                                                                                                                                                    let _v6637 = v6650 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6653 : Ref<Str> = _v6637 
                                                                                                                                                                                                    let v6658 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6659 : string = "String::from($0)"
                                                                                                                                                                                                    let v6660 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6653 v6659 
                                                                                                                                                                                                    let _v6658 = v6660 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6661 : string = "String::from($0)"
                                                                                                                                                                                                    let v6662 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6653 v6661 
                                                                                                                                                                                                    let _v6658 = v6662 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6663 : string = "String::from($0)"
                                                                                                                                                                                                    let v6664 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6653 v6663 
                                                                                                                                                                                                    let _v6658 = v6664 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6665 : std_string_String = v6653 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v6658 = v6665 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6668 : std_string_String = v6653 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v6658 = v6668 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6671 : std_string_String = v6653 |> unbox<std_string_String>
                                                                                                                                                                                                    let _v6658 = v6671 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6674 : std_string_String = _v6658 
                                                                                                                                                                                                    let v6679 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6680 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v6681 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6674 v6680 
                                                                                                                                                                                                    let _v6679 = v6681 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6682 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v6683 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6674 v6682 
                                                                                                                                                                                                    let _v6679 = v6683 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6684 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                    let v6685 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6674 v6684 
                                                                                                                                                                                                    let _v6679 = v6685 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6686 : std_path_PathBuf = v6674 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v6679 = v6686 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6689 : std_path_PathBuf = v6674 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v6679 = v6689 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6692 : std_path_PathBuf = v6674 |> std_path_PathBuf 
                                                                                                                                                                                                    let _v6679 = v6692 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6695 : std_path_PathBuf = _v6679 
                                                                                                                                                                                                    let v6700 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v6701 : string = "Ok($0)"
                                                                                                                                                                                                    let v6702 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6695 v6701 
                                                                                                                                                                                                    let _v6700 = v6702 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v6703 : string = "Ok($0)"
                                                                                                                                                                                                    let v6704 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6695 v6703 
                                                                                                                                                                                                    let _v6700 = v6704 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v6705 : string = "Ok($0)"
                                                                                                                                                                                                    let v6706 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6695 v6705 
                                                                                                                                                                                                    let _v6700 = v6706 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v6707 : Result<std_path_PathBuf, std_io_Error> = v6695 |> Ok
                                                                                                                                                                                                    let _v6700 = v6707 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v6708 : Result<std_path_PathBuf, std_io_Error> = v6695 |> Ok
                                                                                                                                                                                                    let _v6700 = v6708 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v6709 : Result<std_path_PathBuf, std_io_Error> = v6695 |> Ok
                                                                                                                                                                                                    let _v6700 = v6709 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v6710 : Result<std_path_PathBuf, std_io_Error> = _v6700 
                                                                                                                                                                                                    v6710
                                                                                                                                                                                            else
                                                                                                                                                                                                let v6743 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6492} / path': {v6457} / name: {v6493}"
                                                                                                                                                                                                let v6744 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6745 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v6746 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6743 v6745 
                                                                                                                                                                                                let _v6744 = v6746 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6747 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v6748 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6743 v6747 
                                                                                                                                                                                                let _v6744 = v6748 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6749 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v6750 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6743 v6749 
                                                                                                                                                                                                let _v6744 = v6750 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6751 : std_io_Error = v6743 
                                                                                                                                                                                                let _v6744 = v6751 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6752 : std_io_Error = v6743 
                                                                                                                                                                                                let _v6744 = v6752 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6753 : std_io_Error = v6743 
                                                                                                                                                                                                let _v6744 = v6753 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6754 : std_io_Error = _v6744 
                                                                                                                                                                                                let v6757 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v6758 : string = "Err($0)"
                                                                                                                                                                                                let v6759 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6754 v6758 
                                                                                                                                                                                                let _v6757 = v6759 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v6760 : string = "Err($0)"
                                                                                                                                                                                                let v6761 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6754 v6760 
                                                                                                                                                                                                let _v6757 = v6761 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v6762 : string = "Err($0)"
                                                                                                                                                                                                let v6763 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6754 v6762 
                                                                                                                                                                                                let _v6757 = v6763 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v6764 : Result<std_path_PathBuf, std_io_Error> = v6754 |> Error
                                                                                                                                                                                                let _v6757 = v6764 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v6765 : Result<std_path_PathBuf, std_io_Error> = v6754 |> Error
                                                                                                                                                                                                let _v6757 = v6765 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v6766 : Result<std_path_PathBuf, std_io_Error> = v6754 |> Error
                                                                                                                                                                                                let _v6757 = v6766 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v6767 : Result<std_path_PathBuf, std_io_Error> = _v6757 
                                                                                                                                                                                                v6767
                                                                                                                                                                                        | _ ->
                                                                                                                                                                                            let v6771 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6492} / path': {v6457} / name: {v6493}"
                                                                                                                                                                                            let v6772 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v6773 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v6774 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6771 v6773 
                                                                                                                                                                                            let _v6772 = v6774 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v6775 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v6776 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6771 v6775 
                                                                                                                                                                                            let _v6772 = v6776 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v6777 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v6778 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6771 v6777 
                                                                                                                                                                                            let _v6772 = v6778 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v6779 : std_io_Error = v6771 
                                                                                                                                                                                            let _v6772 = v6779 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v6780 : std_io_Error = v6771 
                                                                                                                                                                                            let _v6772 = v6780 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v6781 : std_io_Error = v6771 
                                                                                                                                                                                            let _v6772 = v6781 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v6782 : std_io_Error = _v6772 
                                                                                                                                                                                            let v6785 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v6786 : string = "Err($0)"
                                                                                                                                                                                            let v6787 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6782 v6786 
                                                                                                                                                                                            let _v6785 = v6787 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v6788 : string = "Err($0)"
                                                                                                                                                                                            let v6789 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6782 v6788 
                                                                                                                                                                                            let _v6785 = v6789 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v6790 : string = "Err($0)"
                                                                                                                                                                                            let v6791 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6782 v6790 
                                                                                                                                                                                            let _v6785 = v6791 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v6792 : Result<std_path_PathBuf, std_io_Error> = v6782 |> Error
                                                                                                                                                                                            let _v6785 = v6792 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v6793 : Result<std_path_PathBuf, std_io_Error> = v6782 |> Error
                                                                                                                                                                                            let _v6785 = v6793 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v6794 : Result<std_path_PathBuf, std_io_Error> = v6782 |> Error
                                                                                                                                                                                            let _v6785 = v6794 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v6795 : Result<std_path_PathBuf, std_io_Error> = _v6785 
                                                                                                                                                                                            v6795
                                                                                                                                                                                    | US13_0(v6478) -> (* Ok *)
                                                                                                                                                                                        let v6479 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v6480 : string = "Ok($0)"
                                                                                                                                                                                        let v6481 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6478 v6480 
                                                                                                                                                                                        let _v6479 = v6481 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v6482 : string = "Ok($0)"
                                                                                                                                                                                        let v6483 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6478 v6482 
                                                                                                                                                                                        let _v6479 = v6483 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v6484 : string = "Ok($0)"
                                                                                                                                                                                        let v6485 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6478 v6484 
                                                                                                                                                                                        let _v6479 = v6485 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v6486 : Result<std_path_PathBuf, std_io_Error> = v6478 |> Ok
                                                                                                                                                                                        let _v6479 = v6486 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v6487 : Result<std_path_PathBuf, std_io_Error> = v6478 |> Ok
                                                                                                                                                                                        let _v6479 = v6487 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v6488 : Result<std_path_PathBuf, std_io_Error> = v6478 |> Ok
                                                                                                                                                                                        let _v6479 = v6488 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v6489 : Result<std_path_PathBuf, std_io_Error> = _v6479 
                                                                                                                                                                                        v6489
                                                                                                                                                                                let v6801 : (std_io_Error -> string) = method76()
                                                                                                                                                                                let v6802 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6803 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v6804 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6800, v6801) v6803 
                                                                                                                                                                                let _v6802 = v6804 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6805 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v6806 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6800, v6801) v6805 
                                                                                                                                                                                let _v6802 = v6806 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6807 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                let v6808 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v6800, v6801) v6807 
                                                                                                                                                                                let _v6802 = v6808 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6809 : Result<std_path_PathBuf, string> = match v6800 with Ok x -> Ok x | Error x -> Error (v6801 x)
                                                                                                                                                                                let _v6802 = v6809 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6810 : Result<std_path_PathBuf, string> = match v6800 with Ok x -> Ok x | Error x -> Error (v6801 x)
                                                                                                                                                                                let _v6802 = v6810 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6811 : Result<std_path_PathBuf, string> = match v6800 with Ok x -> Ok x | Error x -> Error (v6801 x)
                                                                                                                                                                                let _v6802 = v6811 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6812 : Result<std_path_PathBuf, string> = _v6802 
                                                                                                                                                                                let v6815 : US13 = match v6812 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                                                                match v6815 with
                                                                                                                                                                                | US13_1(v6918) -> (* Error *)
                                                                                                                                                                                    let v6919 : string = $"file_system.read_link / error': {v6918} / error: {v6437} / name: {v6438}"
                                                                                                                                                                                    let v6920 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v6921 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v6922 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6919 v6921 
                                                                                                                                                                                    let _v6920 = v6922 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v6923 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v6924 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6919 v6923 
                                                                                                                                                                                    let _v6920 = v6924 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v6925 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v6926 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6919 v6925 
                                                                                                                                                                                    let _v6920 = v6926 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v6927 : std_io_Error = v6919 
                                                                                                                                                                                    let _v6920 = v6927 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v6928 : std_io_Error = v6919 
                                                                                                                                                                                    let _v6920 = v6928 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v6929 : std_io_Error = v6919 
                                                                                                                                                                                    let _v6920 = v6929 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v6930 : std_io_Error = _v6920 
                                                                                                                                                                                    let v6933 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v6934 : string = "Err($0)"
                                                                                                                                                                                    let v6935 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6930 v6934 
                                                                                                                                                                                    let _v6933 = v6935 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v6936 : string = "Err($0)"
                                                                                                                                                                                    let v6937 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6930 v6936 
                                                                                                                                                                                    let _v6933 = v6937 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v6938 : string = "Err($0)"
                                                                                                                                                                                    let v6939 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6930 v6938 
                                                                                                                                                                                    let _v6933 = v6939 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v6940 : Result<std_path_PathBuf, std_io_Error> = v6930 |> Error
                                                                                                                                                                                    let _v6933 = v6940 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v6941 : Result<std_path_PathBuf, std_io_Error> = v6930 |> Error
                                                                                                                                                                                    let _v6933 = v6941 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v6942 : Result<std_path_PathBuf, std_io_Error> = v6930 |> Error
                                                                                                                                                                                    let _v6933 = v6942 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v6943 : Result<std_path_PathBuf, std_io_Error> = _v6933 
                                                                                                                                                                                    v6943
                                                                                                                                                                                | US13_0(v6816) -> (* Ok *)
                                                                                                                                                                                    let v6817 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v6818 : string = "$0.display()"
                                                                                                                                                                                    let v6819 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6816 v6818 
                                                                                                                                                                                    let _v6817 = v6819 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v6820 : string = "$0.display()"
                                                                                                                                                                                    let v6821 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6816 v6820 
                                                                                                                                                                                    let _v6817 = v6821 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v6822 : string = "$0.display()"
                                                                                                                                                                                    let v6823 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v6816 v6822 
                                                                                                                                                                                    let _v6817 = v6823 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v6824 : std_path_Display = v6816 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v6817 = v6824 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v6827 : std_path_Display = v6816 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v6817 = v6827 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v6830 : std_path_Display = v6816 |> unbox<std_path_Display>
                                                                                                                                                                                    let _v6817 = v6830 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v6833 : std_path_Display = _v6817 
                                                                                                                                                                                    let v6838 : string = v6833 |> string 
                                                                                                                                                                                    let v6841 : string = method56(v6838, v6438)
                                                                                                                                                                                    let v6842 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v6843 : string = "&*$0"
                                                                                                                                                                                    let v6844 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6841 v6843 
                                                                                                                                                                                    let _v6842 = v6844 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v6845 : string = "&*$0"
                                                                                                                                                                                    let v6846 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6841 v6845 
                                                                                                                                                                                    let _v6842 = v6846 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v6847 : string = "&*$0"
                                                                                                                                                                                    let v6848 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v6841 v6847 
                                                                                                                                                                                    let _v6842 = v6848 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v6849 : Ref<Str> = v6841 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v6842 = v6849 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v6852 : Ref<Str> = v6841 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v6842 = v6852 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v6855 : Ref<Str> = v6841 |> unbox<Ref<Str>>
                                                                                                                                                                                    let _v6842 = v6855 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v6858 : Ref<Str> = _v6842 
                                                                                                                                                                                    let v6863 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v6864 : string = "String::from($0)"
                                                                                                                                                                                    let v6865 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6858 v6864 
                                                                                                                                                                                    let _v6863 = v6865 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v6866 : string = "String::from($0)"
                                                                                                                                                                                    let v6867 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6858 v6866 
                                                                                                                                                                                    let _v6863 = v6867 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v6868 : string = "String::from($0)"
                                                                                                                                                                                    let v6869 : std_string_String = Fable.Core.RustInterop.emitRustExpr v6858 v6868 
                                                                                                                                                                                    let _v6863 = v6869 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v6870 : std_string_String = v6858 |> unbox<std_string_String>
                                                                                                                                                                                    let _v6863 = v6870 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v6873 : std_string_String = v6858 |> unbox<std_string_String>
                                                                                                                                                                                    let _v6863 = v6873 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v6876 : std_string_String = v6858 |> unbox<std_string_String>
                                                                                                                                                                                    let _v6863 = v6876 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v6879 : std_string_String = _v6863 
                                                                                                                                                                                    let v6884 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v6885 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v6886 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6879 v6885 
                                                                                                                                                                                    let _v6884 = v6886 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v6887 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v6888 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6879 v6887 
                                                                                                                                                                                    let _v6884 = v6888 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v6889 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                    let v6890 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v6879 v6889 
                                                                                                                                                                                    let _v6884 = v6890 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v6891 : std_path_PathBuf = v6879 |> std_path_PathBuf 
                                                                                                                                                                                    let _v6884 = v6891 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v6894 : std_path_PathBuf = v6879 |> std_path_PathBuf 
                                                                                                                                                                                    let _v6884 = v6894 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v6897 : std_path_PathBuf = v6879 |> std_path_PathBuf 
                                                                                                                                                                                    let _v6884 = v6897 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v6900 : std_path_PathBuf = _v6884 
                                                                                                                                                                                    let v6905 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v6906 : string = "Ok($0)"
                                                                                                                                                                                    let v6907 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6900 v6906 
                                                                                                                                                                                    let _v6905 = v6907 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v6908 : string = "Ok($0)"
                                                                                                                                                                                    let v6909 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6900 v6908 
                                                                                                                                                                                    let _v6905 = v6909 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v6910 : string = "Ok($0)"
                                                                                                                                                                                    let v6911 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6900 v6910 
                                                                                                                                                                                    let _v6905 = v6911 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v6912 : Result<std_path_PathBuf, std_io_Error> = v6900 |> Ok
                                                                                                                                                                                    let _v6905 = v6912 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v6913 : Result<std_path_PathBuf, std_io_Error> = v6900 |> Ok
                                                                                                                                                                                    let _v6905 = v6913 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v6914 : Result<std_path_PathBuf, std_io_Error> = v6900 |> Ok
                                                                                                                                                                                    let _v6905 = v6914 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v6915 : Result<std_path_PathBuf, std_io_Error> = _v6905 
                                                                                                                                                                                    v6915
                                                                                                                                                                            else
                                                                                                                                                                                let v6948 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6437} / path': {v6402} / name: {v6438}"
                                                                                                                                                                                let v6949 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6950 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v6951 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6948 v6950 
                                                                                                                                                                                let _v6949 = v6951 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6952 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v6953 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6948 v6952 
                                                                                                                                                                                let _v6949 = v6953 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6954 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v6955 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6948 v6954 
                                                                                                                                                                                let _v6949 = v6955 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6956 : std_io_Error = v6948 
                                                                                                                                                                                let _v6949 = v6956 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6957 : std_io_Error = v6948 
                                                                                                                                                                                let _v6949 = v6957 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6958 : std_io_Error = v6948 
                                                                                                                                                                                let _v6949 = v6958 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6959 : std_io_Error = _v6949 
                                                                                                                                                                                let v6962 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v6963 : string = "Err($0)"
                                                                                                                                                                                let v6964 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6959 v6963 
                                                                                                                                                                                let _v6962 = v6964 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v6965 : string = "Err($0)"
                                                                                                                                                                                let v6966 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6959 v6965 
                                                                                                                                                                                let _v6962 = v6966 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v6967 : string = "Err($0)"
                                                                                                                                                                                let v6968 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6959 v6967 
                                                                                                                                                                                let _v6962 = v6968 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v6969 : Result<std_path_PathBuf, std_io_Error> = v6959 |> Error
                                                                                                                                                                                let _v6962 = v6969 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v6970 : Result<std_path_PathBuf, std_io_Error> = v6959 |> Error
                                                                                                                                                                                let _v6962 = v6970 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v6971 : Result<std_path_PathBuf, std_io_Error> = v6959 |> Error
                                                                                                                                                                                let _v6962 = v6971 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v6972 : Result<std_path_PathBuf, std_io_Error> = _v6962 
                                                                                                                                                                                v6972
                                                                                                                                                                        | _ ->
                                                                                                                                                                            let v6976 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6437} / path': {v6402} / name: {v6438}"
                                                                                                                                                                            let v6977 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v6978 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v6979 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6976 v6978 
                                                                                                                                                                            let _v6977 = v6979 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v6980 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v6981 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6976 v6980 
                                                                                                                                                                            let _v6977 = v6981 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v6982 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v6983 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v6976 v6982 
                                                                                                                                                                            let _v6977 = v6983 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v6984 : std_io_Error = v6976 
                                                                                                                                                                            let _v6977 = v6984 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v6985 : std_io_Error = v6976 
                                                                                                                                                                            let _v6977 = v6985 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v6986 : std_io_Error = v6976 
                                                                                                                                                                            let _v6977 = v6986 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v6987 : std_io_Error = _v6977 
                                                                                                                                                                            let v6990 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v6991 : string = "Err($0)"
                                                                                                                                                                            let v6992 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6987 v6991 
                                                                                                                                                                            let _v6990 = v6992 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v6993 : string = "Err($0)"
                                                                                                                                                                            let v6994 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6987 v6993 
                                                                                                                                                                            let _v6990 = v6994 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v6995 : string = "Err($0)"
                                                                                                                                                                            let v6996 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6987 v6995 
                                                                                                                                                                            let _v6990 = v6996 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v6997 : Result<std_path_PathBuf, std_io_Error> = v6987 |> Error
                                                                                                                                                                            let _v6990 = v6997 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v6998 : Result<std_path_PathBuf, std_io_Error> = v6987 |> Error
                                                                                                                                                                            let _v6990 = v6998 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v6999 : Result<std_path_PathBuf, std_io_Error> = v6987 |> Error
                                                                                                                                                                            let _v6990 = v6999 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v7000 : Result<std_path_PathBuf, std_io_Error> = _v6990 
                                                                                                                                                                            v7000
                                                                                                                                                                    | US13_0(v6423) -> (* Ok *)
                                                                                                                                                                        let v6424 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v6425 : string = "Ok($0)"
                                                                                                                                                                        let v6426 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6423 v6425 
                                                                                                                                                                        let _v6424 = v6426 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v6427 : string = "Ok($0)"
                                                                                                                                                                        let v6428 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6423 v6427 
                                                                                                                                                                        let _v6424 = v6428 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v6429 : string = "Ok($0)"
                                                                                                                                                                        let v6430 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6423 v6429 
                                                                                                                                                                        let _v6424 = v6430 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v6431 : Result<std_path_PathBuf, std_io_Error> = v6423 |> Ok
                                                                                                                                                                        let _v6424 = v6431 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v6432 : Result<std_path_PathBuf, std_io_Error> = v6423 |> Ok
                                                                                                                                                                        let _v6424 = v6432 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v6433 : Result<std_path_PathBuf, std_io_Error> = v6423 |> Ok
                                                                                                                                                                        let _v6424 = v6433 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v6434 : Result<std_path_PathBuf, std_io_Error> = _v6424 
                                                                                                                                                                        v6434
                                                                                                                                                                let v7006 : (std_io_Error -> string) = method76()
                                                                                                                                                                let v7007 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7008 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v7009 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7005, v7006) v7008 
                                                                                                                                                                let _v7007 = v7009 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7010 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v7011 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7005, v7006) v7010 
                                                                                                                                                                let _v7007 = v7011 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7012 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                let v7013 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7005, v7006) v7012 
                                                                                                                                                                let _v7007 = v7013 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7014 : Result<std_path_PathBuf, string> = match v7005 with Ok x -> Ok x | Error x -> Error (v7006 x)
                                                                                                                                                                let _v7007 = v7014 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7015 : Result<std_path_PathBuf, string> = match v7005 with Ok x -> Ok x | Error x -> Error (v7006 x)
                                                                                                                                                                let _v7007 = v7015 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7016 : Result<std_path_PathBuf, string> = match v7005 with Ok x -> Ok x | Error x -> Error (v7006 x)
                                                                                                                                                                let _v7007 = v7016 
                                                                                                                                                                #endif
                                                                                                                                                                let v7017 : Result<std_path_PathBuf, string> = _v7007 
                                                                                                                                                                let v7020 : US13 = match v7017 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                                                match v7020 with
                                                                                                                                                                | US13_1(v7123) -> (* Error *)
                                                                                                                                                                    let v7124 : string = $"file_system.read_link / error': {v7123} / error: {v6382} / name: {v6383}"
                                                                                                                                                                    let v7125 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v7126 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v7127 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7124 v7126 
                                                                                                                                                                    let _v7125 = v7127 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v7128 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v7129 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7124 v7128 
                                                                                                                                                                    let _v7125 = v7129 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v7130 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v7131 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7124 v7130 
                                                                                                                                                                    let _v7125 = v7131 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v7132 : std_io_Error = v7124 
                                                                                                                                                                    let _v7125 = v7132 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v7133 : std_io_Error = v7124 
                                                                                                                                                                    let _v7125 = v7133 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v7134 : std_io_Error = v7124 
                                                                                                                                                                    let _v7125 = v7134 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v7135 : std_io_Error = _v7125 
                                                                                                                                                                    let v7138 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v7139 : string = "Err($0)"
                                                                                                                                                                    let v7140 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7135 v7139 
                                                                                                                                                                    let _v7138 = v7140 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v7141 : string = "Err($0)"
                                                                                                                                                                    let v7142 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7135 v7141 
                                                                                                                                                                    let _v7138 = v7142 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v7143 : string = "Err($0)"
                                                                                                                                                                    let v7144 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7135 v7143 
                                                                                                                                                                    let _v7138 = v7144 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v7145 : Result<std_path_PathBuf, std_io_Error> = v7135 |> Error
                                                                                                                                                                    let _v7138 = v7145 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v7146 : Result<std_path_PathBuf, std_io_Error> = v7135 |> Error
                                                                                                                                                                    let _v7138 = v7146 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v7147 : Result<std_path_PathBuf, std_io_Error> = v7135 |> Error
                                                                                                                                                                    let _v7138 = v7147 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v7148 : Result<std_path_PathBuf, std_io_Error> = _v7138 
                                                                                                                                                                    v7148
                                                                                                                                                                | US13_0(v7021) -> (* Ok *)
                                                                                                                                                                    let v7022 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v7023 : string = "$0.display()"
                                                                                                                                                                    let v7024 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7021 v7023 
                                                                                                                                                                    let _v7022 = v7024 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v7025 : string = "$0.display()"
                                                                                                                                                                    let v7026 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7021 v7025 
                                                                                                                                                                    let _v7022 = v7026 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v7027 : string = "$0.display()"
                                                                                                                                                                    let v7028 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7021 v7027 
                                                                                                                                                                    let _v7022 = v7028 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v7029 : std_path_Display = v7021 |> unbox<std_path_Display>
                                                                                                                                                                    let _v7022 = v7029 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v7032 : std_path_Display = v7021 |> unbox<std_path_Display>
                                                                                                                                                                    let _v7022 = v7032 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v7035 : std_path_Display = v7021 |> unbox<std_path_Display>
                                                                                                                                                                    let _v7022 = v7035 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v7038 : std_path_Display = _v7022 
                                                                                                                                                                    let v7043 : string = v7038 |> string 
                                                                                                                                                                    let v7046 : string = method56(v7043, v6383)
                                                                                                                                                                    let v7047 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v7048 : string = "&*$0"
                                                                                                                                                                    let v7049 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7046 v7048 
                                                                                                                                                                    let _v7047 = v7049 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v7050 : string = "&*$0"
                                                                                                                                                                    let v7051 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7046 v7050 
                                                                                                                                                                    let _v7047 = v7051 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v7052 : string = "&*$0"
                                                                                                                                                                    let v7053 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7046 v7052 
                                                                                                                                                                    let _v7047 = v7053 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v7054 : Ref<Str> = v7046 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v7047 = v7054 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v7057 : Ref<Str> = v7046 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v7047 = v7057 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v7060 : Ref<Str> = v7046 |> unbox<Ref<Str>>
                                                                                                                                                                    let _v7047 = v7060 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v7063 : Ref<Str> = _v7047 
                                                                                                                                                                    let v7068 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v7069 : string = "String::from($0)"
                                                                                                                                                                    let v7070 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7063 v7069 
                                                                                                                                                                    let _v7068 = v7070 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v7071 : string = "String::from($0)"
                                                                                                                                                                    let v7072 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7063 v7071 
                                                                                                                                                                    let _v7068 = v7072 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v7073 : string = "String::from($0)"
                                                                                                                                                                    let v7074 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7063 v7073 
                                                                                                                                                                    let _v7068 = v7074 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v7075 : std_string_String = v7063 |> unbox<std_string_String>
                                                                                                                                                                    let _v7068 = v7075 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v7078 : std_string_String = v7063 |> unbox<std_string_String>
                                                                                                                                                                    let _v7068 = v7078 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v7081 : std_string_String = v7063 |> unbox<std_string_String>
                                                                                                                                                                    let _v7068 = v7081 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v7084 : std_string_String = _v7068 
                                                                                                                                                                    let v7089 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v7090 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v7091 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7084 v7090 
                                                                                                                                                                    let _v7089 = v7091 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v7092 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v7093 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7084 v7092 
                                                                                                                                                                    let _v7089 = v7093 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v7094 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                    let v7095 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7084 v7094 
                                                                                                                                                                    let _v7089 = v7095 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v7096 : std_path_PathBuf = v7084 |> std_path_PathBuf 
                                                                                                                                                                    let _v7089 = v7096 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v7099 : std_path_PathBuf = v7084 |> std_path_PathBuf 
                                                                                                                                                                    let _v7089 = v7099 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v7102 : std_path_PathBuf = v7084 |> std_path_PathBuf 
                                                                                                                                                                    let _v7089 = v7102 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v7105 : std_path_PathBuf = _v7089 
                                                                                                                                                                    let v7110 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v7111 : string = "Ok($0)"
                                                                                                                                                                    let v7112 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7105 v7111 
                                                                                                                                                                    let _v7110 = v7112 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v7113 : string = "Ok($0)"
                                                                                                                                                                    let v7114 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7105 v7113 
                                                                                                                                                                    let _v7110 = v7114 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v7115 : string = "Ok($0)"
                                                                                                                                                                    let v7116 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7105 v7115 
                                                                                                                                                                    let _v7110 = v7116 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v7117 : Result<std_path_PathBuf, std_io_Error> = v7105 |> Ok
                                                                                                                                                                    let _v7110 = v7117 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v7118 : Result<std_path_PathBuf, std_io_Error> = v7105 |> Ok
                                                                                                                                                                    let _v7110 = v7118 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v7119 : Result<std_path_PathBuf, std_io_Error> = v7105 |> Ok
                                                                                                                                                                    let _v7110 = v7119 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v7120 : Result<std_path_PathBuf, std_io_Error> = _v7110 
                                                                                                                                                                    v7120
                                                                                                                                                            else
                                                                                                                                                                let v7153 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6382} / path': {v6347} / name: {v6383}"
                                                                                                                                                                let v7154 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7155 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v7156 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7153 v7155 
                                                                                                                                                                let _v7154 = v7156 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7157 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v7158 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7153 v7157 
                                                                                                                                                                let _v7154 = v7158 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7159 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v7160 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7153 v7159 
                                                                                                                                                                let _v7154 = v7160 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7161 : std_io_Error = v7153 
                                                                                                                                                                let _v7154 = v7161 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7162 : std_io_Error = v7153 
                                                                                                                                                                let _v7154 = v7162 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7163 : std_io_Error = v7153 
                                                                                                                                                                let _v7154 = v7163 
                                                                                                                                                                #endif
                                                                                                                                                                let v7164 : std_io_Error = _v7154 
                                                                                                                                                                let v7167 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v7168 : string = "Err($0)"
                                                                                                                                                                let v7169 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7164 v7168 
                                                                                                                                                                let _v7167 = v7169 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v7170 : string = "Err($0)"
                                                                                                                                                                let v7171 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7164 v7170 
                                                                                                                                                                let _v7167 = v7171 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v7172 : string = "Err($0)"
                                                                                                                                                                let v7173 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7164 v7172 
                                                                                                                                                                let _v7167 = v7173 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v7174 : Result<std_path_PathBuf, std_io_Error> = v7164 |> Error
                                                                                                                                                                let _v7167 = v7174 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v7175 : Result<std_path_PathBuf, std_io_Error> = v7164 |> Error
                                                                                                                                                                let _v7167 = v7175 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v7176 : Result<std_path_PathBuf, std_io_Error> = v7164 |> Error
                                                                                                                                                                let _v7167 = v7176 
                                                                                                                                                                #endif
                                                                                                                                                                let v7177 : Result<std_path_PathBuf, std_io_Error> = _v7167 
                                                                                                                                                                v7177
                                                                                                                                                        | _ ->
                                                                                                                                                            let v7181 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6382} / path': {v6347} / name: {v6383}"
                                                                                                                                                            let v7182 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v7183 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v7184 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7181 v7183 
                                                                                                                                                            let _v7182 = v7184 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v7185 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v7186 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7181 v7185 
                                                                                                                                                            let _v7182 = v7186 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v7187 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v7188 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7181 v7187 
                                                                                                                                                            let _v7182 = v7188 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v7189 : std_io_Error = v7181 
                                                                                                                                                            let _v7182 = v7189 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v7190 : std_io_Error = v7181 
                                                                                                                                                            let _v7182 = v7190 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v7191 : std_io_Error = v7181 
                                                                                                                                                            let _v7182 = v7191 
                                                                                                                                                            #endif
                                                                                                                                                            let v7192 : std_io_Error = _v7182 
                                                                                                                                                            let v7195 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v7196 : string = "Err($0)"
                                                                                                                                                            let v7197 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7192 v7196 
                                                                                                                                                            let _v7195 = v7197 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v7198 : string = "Err($0)"
                                                                                                                                                            let v7199 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7192 v7198 
                                                                                                                                                            let _v7195 = v7199 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v7200 : string = "Err($0)"
                                                                                                                                                            let v7201 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7192 v7200 
                                                                                                                                                            let _v7195 = v7201 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v7202 : Result<std_path_PathBuf, std_io_Error> = v7192 |> Error
                                                                                                                                                            let _v7195 = v7202 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v7203 : Result<std_path_PathBuf, std_io_Error> = v7192 |> Error
                                                                                                                                                            let _v7195 = v7203 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v7204 : Result<std_path_PathBuf, std_io_Error> = v7192 |> Error
                                                                                                                                                            let _v7195 = v7204 
                                                                                                                                                            #endif
                                                                                                                                                            let v7205 : Result<std_path_PathBuf, std_io_Error> = _v7195 
                                                                                                                                                            v7205
                                                                                                                                                    | US13_0(v6368) -> (* Ok *)
                                                                                                                                                        let v6369 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v6370 : string = "Ok($0)"
                                                                                                                                                        let v6371 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6368 v6370 
                                                                                                                                                        let _v6369 = v6371 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v6372 : string = "Ok($0)"
                                                                                                                                                        let v6373 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6368 v6372 
                                                                                                                                                        let _v6369 = v6373 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v6374 : string = "Ok($0)"
                                                                                                                                                        let v6375 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6368 v6374 
                                                                                                                                                        let _v6369 = v6375 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v6376 : Result<std_path_PathBuf, std_io_Error> = v6368 |> Ok
                                                                                                                                                        let _v6369 = v6376 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v6377 : Result<std_path_PathBuf, std_io_Error> = v6368 |> Ok
                                                                                                                                                        let _v6369 = v6377 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v6378 : Result<std_path_PathBuf, std_io_Error> = v6368 |> Ok
                                                                                                                                                        let _v6369 = v6378 
                                                                                                                                                        #endif
                                                                                                                                                        let v6379 : Result<std_path_PathBuf, std_io_Error> = _v6369 
                                                                                                                                                        v6379
                                                                                                                                                let v7211 : (std_io_Error -> string) = method76()
                                                                                                                                                let v7212 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7213 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v7214 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7210, v7211) v7213 
                                                                                                                                                let _v7212 = v7214 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7215 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v7216 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7210, v7211) v7215 
                                                                                                                                                let _v7212 = v7216 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7217 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                let v7218 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7210, v7211) v7217 
                                                                                                                                                let _v7212 = v7218 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7219 : Result<std_path_PathBuf, string> = match v7210 with Ok x -> Ok x | Error x -> Error (v7211 x)
                                                                                                                                                let _v7212 = v7219 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7220 : Result<std_path_PathBuf, string> = match v7210 with Ok x -> Ok x | Error x -> Error (v7211 x)
                                                                                                                                                let _v7212 = v7220 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7221 : Result<std_path_PathBuf, string> = match v7210 with Ok x -> Ok x | Error x -> Error (v7211 x)
                                                                                                                                                let _v7212 = v7221 
                                                                                                                                                #endif
                                                                                                                                                let v7222 : Result<std_path_PathBuf, string> = _v7212 
                                                                                                                                                let v7225 : US13 = match v7222 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                                match v7225 with
                                                                                                                                                | US13_1(v7328) -> (* Error *)
                                                                                                                                                    let v7329 : string = $"file_system.read_link / error': {v7328} / error: {v6327} / name: {v6328}"
                                                                                                                                                    let v7330 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v7331 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v7332 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7329 v7331 
                                                                                                                                                    let _v7330 = v7332 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v7333 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v7334 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7329 v7333 
                                                                                                                                                    let _v7330 = v7334 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v7335 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v7336 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7329 v7335 
                                                                                                                                                    let _v7330 = v7336 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v7337 : std_io_Error = v7329 
                                                                                                                                                    let _v7330 = v7337 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v7338 : std_io_Error = v7329 
                                                                                                                                                    let _v7330 = v7338 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v7339 : std_io_Error = v7329 
                                                                                                                                                    let _v7330 = v7339 
                                                                                                                                                    #endif
                                                                                                                                                    let v7340 : std_io_Error = _v7330 
                                                                                                                                                    let v7343 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v7344 : string = "Err($0)"
                                                                                                                                                    let v7345 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7340 v7344 
                                                                                                                                                    let _v7343 = v7345 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v7346 : string = "Err($0)"
                                                                                                                                                    let v7347 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7340 v7346 
                                                                                                                                                    let _v7343 = v7347 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v7348 : string = "Err($0)"
                                                                                                                                                    let v7349 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7340 v7348 
                                                                                                                                                    let _v7343 = v7349 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v7350 : Result<std_path_PathBuf, std_io_Error> = v7340 |> Error
                                                                                                                                                    let _v7343 = v7350 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v7351 : Result<std_path_PathBuf, std_io_Error> = v7340 |> Error
                                                                                                                                                    let _v7343 = v7351 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v7352 : Result<std_path_PathBuf, std_io_Error> = v7340 |> Error
                                                                                                                                                    let _v7343 = v7352 
                                                                                                                                                    #endif
                                                                                                                                                    let v7353 : Result<std_path_PathBuf, std_io_Error> = _v7343 
                                                                                                                                                    v7353
                                                                                                                                                | US13_0(v7226) -> (* Ok *)
                                                                                                                                                    let v7227 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v7228 : string = "$0.display()"
                                                                                                                                                    let v7229 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7226 v7228 
                                                                                                                                                    let _v7227 = v7229 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v7230 : string = "$0.display()"
                                                                                                                                                    let v7231 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7226 v7230 
                                                                                                                                                    let _v7227 = v7231 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v7232 : string = "$0.display()"
                                                                                                                                                    let v7233 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7226 v7232 
                                                                                                                                                    let _v7227 = v7233 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v7234 : std_path_Display = v7226 |> unbox<std_path_Display>
                                                                                                                                                    let _v7227 = v7234 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v7237 : std_path_Display = v7226 |> unbox<std_path_Display>
                                                                                                                                                    let _v7227 = v7237 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v7240 : std_path_Display = v7226 |> unbox<std_path_Display>
                                                                                                                                                    let _v7227 = v7240 
                                                                                                                                                    #endif
                                                                                                                                                    let v7243 : std_path_Display = _v7227 
                                                                                                                                                    let v7248 : string = v7243 |> string 
                                                                                                                                                    let v7251 : string = method56(v7248, v6328)
                                                                                                                                                    let v7252 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v7253 : string = "&*$0"
                                                                                                                                                    let v7254 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7251 v7253 
                                                                                                                                                    let _v7252 = v7254 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v7255 : string = "&*$0"
                                                                                                                                                    let v7256 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7251 v7255 
                                                                                                                                                    let _v7252 = v7256 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v7257 : string = "&*$0"
                                                                                                                                                    let v7258 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7251 v7257 
                                                                                                                                                    let _v7252 = v7258 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v7259 : Ref<Str> = v7251 |> unbox<Ref<Str>>
                                                                                                                                                    let _v7252 = v7259 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v7262 : Ref<Str> = v7251 |> unbox<Ref<Str>>
                                                                                                                                                    let _v7252 = v7262 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v7265 : Ref<Str> = v7251 |> unbox<Ref<Str>>
                                                                                                                                                    let _v7252 = v7265 
                                                                                                                                                    #endif
                                                                                                                                                    let v7268 : Ref<Str> = _v7252 
                                                                                                                                                    let v7273 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v7274 : string = "String::from($0)"
                                                                                                                                                    let v7275 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7268 v7274 
                                                                                                                                                    let _v7273 = v7275 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v7276 : string = "String::from($0)"
                                                                                                                                                    let v7277 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7268 v7276 
                                                                                                                                                    let _v7273 = v7277 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v7278 : string = "String::from($0)"
                                                                                                                                                    let v7279 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7268 v7278 
                                                                                                                                                    let _v7273 = v7279 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v7280 : std_string_String = v7268 |> unbox<std_string_String>
                                                                                                                                                    let _v7273 = v7280 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v7283 : std_string_String = v7268 |> unbox<std_string_String>
                                                                                                                                                    let _v7273 = v7283 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v7286 : std_string_String = v7268 |> unbox<std_string_String>
                                                                                                                                                    let _v7273 = v7286 
                                                                                                                                                    #endif
                                                                                                                                                    let v7289 : std_string_String = _v7273 
                                                                                                                                                    let v7294 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v7295 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v7296 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7289 v7295 
                                                                                                                                                    let _v7294 = v7296 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v7297 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v7298 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7289 v7297 
                                                                                                                                                    let _v7294 = v7298 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v7299 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                    let v7300 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7289 v7299 
                                                                                                                                                    let _v7294 = v7300 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v7301 : std_path_PathBuf = v7289 |> std_path_PathBuf 
                                                                                                                                                    let _v7294 = v7301 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v7304 : std_path_PathBuf = v7289 |> std_path_PathBuf 
                                                                                                                                                    let _v7294 = v7304 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v7307 : std_path_PathBuf = v7289 |> std_path_PathBuf 
                                                                                                                                                    let _v7294 = v7307 
                                                                                                                                                    #endif
                                                                                                                                                    let v7310 : std_path_PathBuf = _v7294 
                                                                                                                                                    let v7315 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v7316 : string = "Ok($0)"
                                                                                                                                                    let v7317 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7310 v7316 
                                                                                                                                                    let _v7315 = v7317 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v7318 : string = "Ok($0)"
                                                                                                                                                    let v7319 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7310 v7318 
                                                                                                                                                    let _v7315 = v7319 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v7320 : string = "Ok($0)"
                                                                                                                                                    let v7321 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7310 v7320 
                                                                                                                                                    let _v7315 = v7321 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v7322 : Result<std_path_PathBuf, std_io_Error> = v7310 |> Ok
                                                                                                                                                    let _v7315 = v7322 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v7323 : Result<std_path_PathBuf, std_io_Error> = v7310 |> Ok
                                                                                                                                                    let _v7315 = v7323 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v7324 : Result<std_path_PathBuf, std_io_Error> = v7310 |> Ok
                                                                                                                                                    let _v7315 = v7324 
                                                                                                                                                    #endif
                                                                                                                                                    let v7325 : Result<std_path_PathBuf, std_io_Error> = _v7315 
                                                                                                                                                    v7325
                                                                                                                                            else
                                                                                                                                                let v7358 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6327} / path': {v6292} / name: {v6328}"
                                                                                                                                                let v7359 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7360 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v7361 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7358 v7360 
                                                                                                                                                let _v7359 = v7361 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7362 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v7363 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7358 v7362 
                                                                                                                                                let _v7359 = v7363 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7364 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v7365 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7358 v7364 
                                                                                                                                                let _v7359 = v7365 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7366 : std_io_Error = v7358 
                                                                                                                                                let _v7359 = v7366 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7367 : std_io_Error = v7358 
                                                                                                                                                let _v7359 = v7367 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7368 : std_io_Error = v7358 
                                                                                                                                                let _v7359 = v7368 
                                                                                                                                                #endif
                                                                                                                                                let v7369 : std_io_Error = _v7359 
                                                                                                                                                let v7372 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v7373 : string = "Err($0)"
                                                                                                                                                let v7374 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7369 v7373 
                                                                                                                                                let _v7372 = v7374 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v7375 : string = "Err($0)"
                                                                                                                                                let v7376 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7369 v7375 
                                                                                                                                                let _v7372 = v7376 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v7377 : string = "Err($0)"
                                                                                                                                                let v7378 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7369 v7377 
                                                                                                                                                let _v7372 = v7378 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v7379 : Result<std_path_PathBuf, std_io_Error> = v7369 |> Error
                                                                                                                                                let _v7372 = v7379 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v7380 : Result<std_path_PathBuf, std_io_Error> = v7369 |> Error
                                                                                                                                                let _v7372 = v7380 
                                                                                                                                                #endif
#else
                                                                                                                                                let v7381 : Result<std_path_PathBuf, std_io_Error> = v7369 |> Error
                                                                                                                                                let _v7372 = v7381 
                                                                                                                                                #endif
                                                                                                                                                let v7382 : Result<std_path_PathBuf, std_io_Error> = _v7372 
                                                                                                                                                v7382
                                                                                                                                        | _ ->
                                                                                                                                            let v7386 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6327} / path': {v6292} / name: {v6328}"
                                                                                                                                            let v7387 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v7388 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v7389 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7386 v7388 
                                                                                                                                            let _v7387 = v7389 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v7390 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v7391 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7386 v7390 
                                                                                                                                            let _v7387 = v7391 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v7392 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v7393 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7386 v7392 
                                                                                                                                            let _v7387 = v7393 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v7394 : std_io_Error = v7386 
                                                                                                                                            let _v7387 = v7394 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v7395 : std_io_Error = v7386 
                                                                                                                                            let _v7387 = v7395 
                                                                                                                                            #endif
#else
                                                                                                                                            let v7396 : std_io_Error = v7386 
                                                                                                                                            let _v7387 = v7396 
                                                                                                                                            #endif
                                                                                                                                            let v7397 : std_io_Error = _v7387 
                                                                                                                                            let v7400 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v7401 : string = "Err($0)"
                                                                                                                                            let v7402 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7397 v7401 
                                                                                                                                            let _v7400 = v7402 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v7403 : string = "Err($0)"
                                                                                                                                            let v7404 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7397 v7403 
                                                                                                                                            let _v7400 = v7404 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v7405 : string = "Err($0)"
                                                                                                                                            let v7406 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7397 v7405 
                                                                                                                                            let _v7400 = v7406 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v7407 : Result<std_path_PathBuf, std_io_Error> = v7397 |> Error
                                                                                                                                            let _v7400 = v7407 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v7408 : Result<std_path_PathBuf, std_io_Error> = v7397 |> Error
                                                                                                                                            let _v7400 = v7408 
                                                                                                                                            #endif
#else
                                                                                                                                            let v7409 : Result<std_path_PathBuf, std_io_Error> = v7397 |> Error
                                                                                                                                            let _v7400 = v7409 
                                                                                                                                            #endif
                                                                                                                                            let v7410 : Result<std_path_PathBuf, std_io_Error> = _v7400 
                                                                                                                                            v7410
                                                                                                                                    | US13_0(v6313) -> (* Ok *)
                                                                                                                                        let v6314 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v6315 : string = "Ok($0)"
                                                                                                                                        let v6316 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6313 v6315 
                                                                                                                                        let _v6314 = v6316 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v6317 : string = "Ok($0)"
                                                                                                                                        let v6318 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6313 v6317 
                                                                                                                                        let _v6314 = v6318 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v6319 : string = "Ok($0)"
                                                                                                                                        let v6320 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6313 v6319 
                                                                                                                                        let _v6314 = v6320 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v6321 : Result<std_path_PathBuf, std_io_Error> = v6313 |> Ok
                                                                                                                                        let _v6314 = v6321 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v6322 : Result<std_path_PathBuf, std_io_Error> = v6313 |> Ok
                                                                                                                                        let _v6314 = v6322 
                                                                                                                                        #endif
#else
                                                                                                                                        let v6323 : Result<std_path_PathBuf, std_io_Error> = v6313 |> Ok
                                                                                                                                        let _v6314 = v6323 
                                                                                                                                        #endif
                                                                                                                                        let v6324 : Result<std_path_PathBuf, std_io_Error> = _v6314 
                                                                                                                                        v6324
                                                                                                                                let v7416 : (std_io_Error -> string) = method76()
                                                                                                                                let v7417 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7418 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v7419 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7415, v7416) v7418 
                                                                                                                                let _v7417 = v7419 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7420 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v7421 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7415, v7416) v7420 
                                                                                                                                let _v7417 = v7421 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7422 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                let v7423 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7415, v7416) v7422 
                                                                                                                                let _v7417 = v7423 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7424 : Result<std_path_PathBuf, string> = match v7415 with Ok x -> Ok x | Error x -> Error (v7416 x)
                                                                                                                                let _v7417 = v7424 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7425 : Result<std_path_PathBuf, string> = match v7415 with Ok x -> Ok x | Error x -> Error (v7416 x)
                                                                                                                                let _v7417 = v7425 
                                                                                                                                #endif
#else
                                                                                                                                let v7426 : Result<std_path_PathBuf, string> = match v7415 with Ok x -> Ok x | Error x -> Error (v7416 x)
                                                                                                                                let _v7417 = v7426 
                                                                                                                                #endif
                                                                                                                                let v7427 : Result<std_path_PathBuf, string> = _v7417 
                                                                                                                                let v7430 : US13 = match v7427 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                                match v7430 with
                                                                                                                                | US13_1(v7533) -> (* Error *)
                                                                                                                                    let v7534 : string = $"file_system.read_link / error': {v7533} / error: {v6272} / name: {v6273}"
                                                                                                                                    let v7535 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v7536 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v7537 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7534 v7536 
                                                                                                                                    let _v7535 = v7537 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v7538 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v7539 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7534 v7538 
                                                                                                                                    let _v7535 = v7539 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v7540 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v7541 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7534 v7540 
                                                                                                                                    let _v7535 = v7541 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v7542 : std_io_Error = v7534 
                                                                                                                                    let _v7535 = v7542 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v7543 : std_io_Error = v7534 
                                                                                                                                    let _v7535 = v7543 
                                                                                                                                    #endif
#else
                                                                                                                                    let v7544 : std_io_Error = v7534 
                                                                                                                                    let _v7535 = v7544 
                                                                                                                                    #endif
                                                                                                                                    let v7545 : std_io_Error = _v7535 
                                                                                                                                    let v7548 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v7549 : string = "Err($0)"
                                                                                                                                    let v7550 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7545 v7549 
                                                                                                                                    let _v7548 = v7550 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v7551 : string = "Err($0)"
                                                                                                                                    let v7552 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7545 v7551 
                                                                                                                                    let _v7548 = v7552 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v7553 : string = "Err($0)"
                                                                                                                                    let v7554 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7545 v7553 
                                                                                                                                    let _v7548 = v7554 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v7555 : Result<std_path_PathBuf, std_io_Error> = v7545 |> Error
                                                                                                                                    let _v7548 = v7555 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v7556 : Result<std_path_PathBuf, std_io_Error> = v7545 |> Error
                                                                                                                                    let _v7548 = v7556 
                                                                                                                                    #endif
#else
                                                                                                                                    let v7557 : Result<std_path_PathBuf, std_io_Error> = v7545 |> Error
                                                                                                                                    let _v7548 = v7557 
                                                                                                                                    #endif
                                                                                                                                    let v7558 : Result<std_path_PathBuf, std_io_Error> = _v7548 
                                                                                                                                    v7558
                                                                                                                                | US13_0(v7431) -> (* Ok *)
                                                                                                                                    let v7432 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v7433 : string = "$0.display()"
                                                                                                                                    let v7434 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7431 v7433 
                                                                                                                                    let _v7432 = v7434 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v7435 : string = "$0.display()"
                                                                                                                                    let v7436 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7431 v7435 
                                                                                                                                    let _v7432 = v7436 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v7437 : string = "$0.display()"
                                                                                                                                    let v7438 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7431 v7437 
                                                                                                                                    let _v7432 = v7438 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v7439 : std_path_Display = v7431 |> unbox<std_path_Display>
                                                                                                                                    let _v7432 = v7439 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v7442 : std_path_Display = v7431 |> unbox<std_path_Display>
                                                                                                                                    let _v7432 = v7442 
                                                                                                                                    #endif
#else
                                                                                                                                    let v7445 : std_path_Display = v7431 |> unbox<std_path_Display>
                                                                                                                                    let _v7432 = v7445 
                                                                                                                                    #endif
                                                                                                                                    let v7448 : std_path_Display = _v7432 
                                                                                                                                    let v7453 : string = v7448 |> string 
                                                                                                                                    let v7456 : string = method56(v7453, v6273)
                                                                                                                                    let v7457 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v7458 : string = "&*$0"
                                                                                                                                    let v7459 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7456 v7458 
                                                                                                                                    let _v7457 = v7459 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v7460 : string = "&*$0"
                                                                                                                                    let v7461 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7456 v7460 
                                                                                                                                    let _v7457 = v7461 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v7462 : string = "&*$0"
                                                                                                                                    let v7463 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7456 v7462 
                                                                                                                                    let _v7457 = v7463 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v7464 : Ref<Str> = v7456 |> unbox<Ref<Str>>
                                                                                                                                    let _v7457 = v7464 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v7467 : Ref<Str> = v7456 |> unbox<Ref<Str>>
                                                                                                                                    let _v7457 = v7467 
                                                                                                                                    #endif
#else
                                                                                                                                    let v7470 : Ref<Str> = v7456 |> unbox<Ref<Str>>
                                                                                                                                    let _v7457 = v7470 
                                                                                                                                    #endif
                                                                                                                                    let v7473 : Ref<Str> = _v7457 
                                                                                                                                    let v7478 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v7479 : string = "String::from($0)"
                                                                                                                                    let v7480 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7473 v7479 
                                                                                                                                    let _v7478 = v7480 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v7481 : string = "String::from($0)"
                                                                                                                                    let v7482 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7473 v7481 
                                                                                                                                    let _v7478 = v7482 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v7483 : string = "String::from($0)"
                                                                                                                                    let v7484 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7473 v7483 
                                                                                                                                    let _v7478 = v7484 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v7485 : std_string_String = v7473 |> unbox<std_string_String>
                                                                                                                                    let _v7478 = v7485 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v7488 : std_string_String = v7473 |> unbox<std_string_String>
                                                                                                                                    let _v7478 = v7488 
                                                                                                                                    #endif
#else
                                                                                                                                    let v7491 : std_string_String = v7473 |> unbox<std_string_String>
                                                                                                                                    let _v7478 = v7491 
                                                                                                                                    #endif
                                                                                                                                    let v7494 : std_string_String = _v7478 
                                                                                                                                    let v7499 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v7500 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v7501 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7494 v7500 
                                                                                                                                    let _v7499 = v7501 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v7502 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v7503 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7494 v7502 
                                                                                                                                    let _v7499 = v7503 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v7504 : string = "std::path::PathBuf::from($0)"
                                                                                                                                    let v7505 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7494 v7504 
                                                                                                                                    let _v7499 = v7505 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v7506 : std_path_PathBuf = v7494 |> std_path_PathBuf 
                                                                                                                                    let _v7499 = v7506 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v7509 : std_path_PathBuf = v7494 |> std_path_PathBuf 
                                                                                                                                    let _v7499 = v7509 
                                                                                                                                    #endif
#else
                                                                                                                                    let v7512 : std_path_PathBuf = v7494 |> std_path_PathBuf 
                                                                                                                                    let _v7499 = v7512 
                                                                                                                                    #endif
                                                                                                                                    let v7515 : std_path_PathBuf = _v7499 
                                                                                                                                    let v7520 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v7521 : string = "Ok($0)"
                                                                                                                                    let v7522 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7515 v7521 
                                                                                                                                    let _v7520 = v7522 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v7523 : string = "Ok($0)"
                                                                                                                                    let v7524 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7515 v7523 
                                                                                                                                    let _v7520 = v7524 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v7525 : string = "Ok($0)"
                                                                                                                                    let v7526 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7515 v7525 
                                                                                                                                    let _v7520 = v7526 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v7527 : Result<std_path_PathBuf, std_io_Error> = v7515 |> Ok
                                                                                                                                    let _v7520 = v7527 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v7528 : Result<std_path_PathBuf, std_io_Error> = v7515 |> Ok
                                                                                                                                    let _v7520 = v7528 
                                                                                                                                    #endif
#else
                                                                                                                                    let v7529 : Result<std_path_PathBuf, std_io_Error> = v7515 |> Ok
                                                                                                                                    let _v7520 = v7529 
                                                                                                                                    #endif
                                                                                                                                    let v7530 : Result<std_path_PathBuf, std_io_Error> = _v7520 
                                                                                                                                    v7530
                                                                                                                            else
                                                                                                                                let v7563 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6272} / path': {v6237} / name: {v6273}"
                                                                                                                                let v7564 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7565 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v7566 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7563 v7565 
                                                                                                                                let _v7564 = v7566 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7567 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v7568 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7563 v7567 
                                                                                                                                let _v7564 = v7568 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7569 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v7570 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7563 v7569 
                                                                                                                                let _v7564 = v7570 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7571 : std_io_Error = v7563 
                                                                                                                                let _v7564 = v7571 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7572 : std_io_Error = v7563 
                                                                                                                                let _v7564 = v7572 
                                                                                                                                #endif
#else
                                                                                                                                let v7573 : std_io_Error = v7563 
                                                                                                                                let _v7564 = v7573 
                                                                                                                                #endif
                                                                                                                                let v7574 : std_io_Error = _v7564 
                                                                                                                                let v7577 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v7578 : string = "Err($0)"
                                                                                                                                let v7579 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7574 v7578 
                                                                                                                                let _v7577 = v7579 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v7580 : string = "Err($0)"
                                                                                                                                let v7581 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7574 v7580 
                                                                                                                                let _v7577 = v7581 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v7582 : string = "Err($0)"
                                                                                                                                let v7583 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7574 v7582 
                                                                                                                                let _v7577 = v7583 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v7584 : Result<std_path_PathBuf, std_io_Error> = v7574 |> Error
                                                                                                                                let _v7577 = v7584 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v7585 : Result<std_path_PathBuf, std_io_Error> = v7574 |> Error
                                                                                                                                let _v7577 = v7585 
                                                                                                                                #endif
#else
                                                                                                                                let v7586 : Result<std_path_PathBuf, std_io_Error> = v7574 |> Error
                                                                                                                                let _v7577 = v7586 
                                                                                                                                #endif
                                                                                                                                let v7587 : Result<std_path_PathBuf, std_io_Error> = _v7577 
                                                                                                                                v7587
                                                                                                                        | _ ->
                                                                                                                            let v7591 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6272} / path': {v6237} / name: {v6273}"
                                                                                                                            let v7592 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v7593 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v7594 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7591 v7593 
                                                                                                                            let _v7592 = v7594 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v7595 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v7596 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7591 v7595 
                                                                                                                            let _v7592 = v7596 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v7597 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v7598 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7591 v7597 
                                                                                                                            let _v7592 = v7598 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v7599 : std_io_Error = v7591 
                                                                                                                            let _v7592 = v7599 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v7600 : std_io_Error = v7591 
                                                                                                                            let _v7592 = v7600 
                                                                                                                            #endif
#else
                                                                                                                            let v7601 : std_io_Error = v7591 
                                                                                                                            let _v7592 = v7601 
                                                                                                                            #endif
                                                                                                                            let v7602 : std_io_Error = _v7592 
                                                                                                                            let v7605 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v7606 : string = "Err($0)"
                                                                                                                            let v7607 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7602 v7606 
                                                                                                                            let _v7605 = v7607 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v7608 : string = "Err($0)"
                                                                                                                            let v7609 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7602 v7608 
                                                                                                                            let _v7605 = v7609 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v7610 : string = "Err($0)"
                                                                                                                            let v7611 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7602 v7610 
                                                                                                                            let _v7605 = v7611 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v7612 : Result<std_path_PathBuf, std_io_Error> = v7602 |> Error
                                                                                                                            let _v7605 = v7612 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v7613 : Result<std_path_PathBuf, std_io_Error> = v7602 |> Error
                                                                                                                            let _v7605 = v7613 
                                                                                                                            #endif
#else
                                                                                                                            let v7614 : Result<std_path_PathBuf, std_io_Error> = v7602 |> Error
                                                                                                                            let _v7605 = v7614 
                                                                                                                            #endif
                                                                                                                            let v7615 : Result<std_path_PathBuf, std_io_Error> = _v7605 
                                                                                                                            v7615
                                                                                                                    | US13_0(v6258) -> (* Ok *)
                                                                                                                        let v6259 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v6260 : string = "Ok($0)"
                                                                                                                        let v6261 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6258 v6260 
                                                                                                                        let _v6259 = v6261 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v6262 : string = "Ok($0)"
                                                                                                                        let v6263 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6258 v6262 
                                                                                                                        let _v6259 = v6263 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v6264 : string = "Ok($0)"
                                                                                                                        let v6265 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6258 v6264 
                                                                                                                        let _v6259 = v6265 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v6266 : Result<std_path_PathBuf, std_io_Error> = v6258 |> Ok
                                                                                                                        let _v6259 = v6266 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v6267 : Result<std_path_PathBuf, std_io_Error> = v6258 |> Ok
                                                                                                                        let _v6259 = v6267 
                                                                                                                        #endif
#else
                                                                                                                        let v6268 : Result<std_path_PathBuf, std_io_Error> = v6258 |> Ok
                                                                                                                        let _v6259 = v6268 
                                                                                                                        #endif
                                                                                                                        let v6269 : Result<std_path_PathBuf, std_io_Error> = _v6259 
                                                                                                                        v6269
                                                                                                                let v7621 : (std_io_Error -> string) = method76()
                                                                                                                let v7622 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7623 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v7624 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7620, v7621) v7623 
                                                                                                                let _v7622 = v7624 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7625 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v7626 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7620, v7621) v7625 
                                                                                                                let _v7622 = v7626 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7627 : string = "$0.map_err(|x| $1(x))"
                                                                                                                let v7628 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7620, v7621) v7627 
                                                                                                                let _v7622 = v7628 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7629 : Result<std_path_PathBuf, string> = match v7620 with Ok x -> Ok x | Error x -> Error (v7621 x)
                                                                                                                let _v7622 = v7629 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7630 : Result<std_path_PathBuf, string> = match v7620 with Ok x -> Ok x | Error x -> Error (v7621 x)
                                                                                                                let _v7622 = v7630 
                                                                                                                #endif
#else
                                                                                                                let v7631 : Result<std_path_PathBuf, string> = match v7620 with Ok x -> Ok x | Error x -> Error (v7621 x)
                                                                                                                let _v7622 = v7631 
                                                                                                                #endif
                                                                                                                let v7632 : Result<std_path_PathBuf, string> = _v7622 
                                                                                                                let v7635 : US13 = match v7632 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                                match v7635 with
                                                                                                                | US13_1(v7738) -> (* Error *)
                                                                                                                    let v7739 : string = $"file_system.read_link / error': {v7738} / error: {v6217} / name: {v6218}"
                                                                                                                    let v7740 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v7741 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v7742 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7739 v7741 
                                                                                                                    let _v7740 = v7742 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v7743 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v7744 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7739 v7743 
                                                                                                                    let _v7740 = v7744 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v7745 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v7746 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7739 v7745 
                                                                                                                    let _v7740 = v7746 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v7747 : std_io_Error = v7739 
                                                                                                                    let _v7740 = v7747 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v7748 : std_io_Error = v7739 
                                                                                                                    let _v7740 = v7748 
                                                                                                                    #endif
#else
                                                                                                                    let v7749 : std_io_Error = v7739 
                                                                                                                    let _v7740 = v7749 
                                                                                                                    #endif
                                                                                                                    let v7750 : std_io_Error = _v7740 
                                                                                                                    let v7753 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v7754 : string = "Err($0)"
                                                                                                                    let v7755 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7750 v7754 
                                                                                                                    let _v7753 = v7755 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v7756 : string = "Err($0)"
                                                                                                                    let v7757 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7750 v7756 
                                                                                                                    let _v7753 = v7757 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v7758 : string = "Err($0)"
                                                                                                                    let v7759 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7750 v7758 
                                                                                                                    let _v7753 = v7759 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v7760 : Result<std_path_PathBuf, std_io_Error> = v7750 |> Error
                                                                                                                    let _v7753 = v7760 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v7761 : Result<std_path_PathBuf, std_io_Error> = v7750 |> Error
                                                                                                                    let _v7753 = v7761 
                                                                                                                    #endif
#else
                                                                                                                    let v7762 : Result<std_path_PathBuf, std_io_Error> = v7750 |> Error
                                                                                                                    let _v7753 = v7762 
                                                                                                                    #endif
                                                                                                                    let v7763 : Result<std_path_PathBuf, std_io_Error> = _v7753 
                                                                                                                    v7763
                                                                                                                | US13_0(v7636) -> (* Ok *)
                                                                                                                    let v7637 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v7638 : string = "$0.display()"
                                                                                                                    let v7639 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7636 v7638 
                                                                                                                    let _v7637 = v7639 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v7640 : string = "$0.display()"
                                                                                                                    let v7641 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7636 v7640 
                                                                                                                    let _v7637 = v7641 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v7642 : string = "$0.display()"
                                                                                                                    let v7643 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7636 v7642 
                                                                                                                    let _v7637 = v7643 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v7644 : std_path_Display = v7636 |> unbox<std_path_Display>
                                                                                                                    let _v7637 = v7644 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v7647 : std_path_Display = v7636 |> unbox<std_path_Display>
                                                                                                                    let _v7637 = v7647 
                                                                                                                    #endif
#else
                                                                                                                    let v7650 : std_path_Display = v7636 |> unbox<std_path_Display>
                                                                                                                    let _v7637 = v7650 
                                                                                                                    #endif
                                                                                                                    let v7653 : std_path_Display = _v7637 
                                                                                                                    let v7658 : string = v7653 |> string 
                                                                                                                    let v7661 : string = method56(v7658, v6218)
                                                                                                                    let v7662 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v7663 : string = "&*$0"
                                                                                                                    let v7664 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7661 v7663 
                                                                                                                    let _v7662 = v7664 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v7665 : string = "&*$0"
                                                                                                                    let v7666 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7661 v7665 
                                                                                                                    let _v7662 = v7666 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v7667 : string = "&*$0"
                                                                                                                    let v7668 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7661 v7667 
                                                                                                                    let _v7662 = v7668 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v7669 : Ref<Str> = v7661 |> unbox<Ref<Str>>
                                                                                                                    let _v7662 = v7669 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v7672 : Ref<Str> = v7661 |> unbox<Ref<Str>>
                                                                                                                    let _v7662 = v7672 
                                                                                                                    #endif
#else
                                                                                                                    let v7675 : Ref<Str> = v7661 |> unbox<Ref<Str>>
                                                                                                                    let _v7662 = v7675 
                                                                                                                    #endif
                                                                                                                    let v7678 : Ref<Str> = _v7662 
                                                                                                                    let v7683 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v7684 : string = "String::from($0)"
                                                                                                                    let v7685 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7678 v7684 
                                                                                                                    let _v7683 = v7685 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v7686 : string = "String::from($0)"
                                                                                                                    let v7687 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7678 v7686 
                                                                                                                    let _v7683 = v7687 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v7688 : string = "String::from($0)"
                                                                                                                    let v7689 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7678 v7688 
                                                                                                                    let _v7683 = v7689 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v7690 : std_string_String = v7678 |> unbox<std_string_String>
                                                                                                                    let _v7683 = v7690 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v7693 : std_string_String = v7678 |> unbox<std_string_String>
                                                                                                                    let _v7683 = v7693 
                                                                                                                    #endif
#else
                                                                                                                    let v7696 : std_string_String = v7678 |> unbox<std_string_String>
                                                                                                                    let _v7683 = v7696 
                                                                                                                    #endif
                                                                                                                    let v7699 : std_string_String = _v7683 
                                                                                                                    let v7704 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v7705 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v7706 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7699 v7705 
                                                                                                                    let _v7704 = v7706 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v7707 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v7708 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7699 v7707 
                                                                                                                    let _v7704 = v7708 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v7709 : string = "std::path::PathBuf::from($0)"
                                                                                                                    let v7710 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7699 v7709 
                                                                                                                    let _v7704 = v7710 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v7711 : std_path_PathBuf = v7699 |> std_path_PathBuf 
                                                                                                                    let _v7704 = v7711 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v7714 : std_path_PathBuf = v7699 |> std_path_PathBuf 
                                                                                                                    let _v7704 = v7714 
                                                                                                                    #endif
#else
                                                                                                                    let v7717 : std_path_PathBuf = v7699 |> std_path_PathBuf 
                                                                                                                    let _v7704 = v7717 
                                                                                                                    #endif
                                                                                                                    let v7720 : std_path_PathBuf = _v7704 
                                                                                                                    let v7725 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v7726 : string = "Ok($0)"
                                                                                                                    let v7727 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7720 v7726 
                                                                                                                    let _v7725 = v7727 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v7728 : string = "Ok($0)"
                                                                                                                    let v7729 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7720 v7728 
                                                                                                                    let _v7725 = v7729 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v7730 : string = "Ok($0)"
                                                                                                                    let v7731 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7720 v7730 
                                                                                                                    let _v7725 = v7731 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v7732 : Result<std_path_PathBuf, std_io_Error> = v7720 |> Ok
                                                                                                                    let _v7725 = v7732 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v7733 : Result<std_path_PathBuf, std_io_Error> = v7720 |> Ok
                                                                                                                    let _v7725 = v7733 
                                                                                                                    #endif
#else
                                                                                                                    let v7734 : Result<std_path_PathBuf, std_io_Error> = v7720 |> Ok
                                                                                                                    let _v7725 = v7734 
                                                                                                                    #endif
                                                                                                                    let v7735 : Result<std_path_PathBuf, std_io_Error> = _v7725 
                                                                                                                    v7735
                                                                                                            else
                                                                                                                let v7768 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6217} / path': {v6182} / name: {v6218}"
                                                                                                                let v7769 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7770 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v7771 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7768 v7770 
                                                                                                                let _v7769 = v7771 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7772 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v7773 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7768 v7772 
                                                                                                                let _v7769 = v7773 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7774 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v7775 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7768 v7774 
                                                                                                                let _v7769 = v7775 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7776 : std_io_Error = v7768 
                                                                                                                let _v7769 = v7776 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7777 : std_io_Error = v7768 
                                                                                                                let _v7769 = v7777 
                                                                                                                #endif
#else
                                                                                                                let v7778 : std_io_Error = v7768 
                                                                                                                let _v7769 = v7778 
                                                                                                                #endif
                                                                                                                let v7779 : std_io_Error = _v7769 
                                                                                                                let v7782 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v7783 : string = "Err($0)"
                                                                                                                let v7784 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7779 v7783 
                                                                                                                let _v7782 = v7784 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v7785 : string = "Err($0)"
                                                                                                                let v7786 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7779 v7785 
                                                                                                                let _v7782 = v7786 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v7787 : string = "Err($0)"
                                                                                                                let v7788 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7779 v7787 
                                                                                                                let _v7782 = v7788 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v7789 : Result<std_path_PathBuf, std_io_Error> = v7779 |> Error
                                                                                                                let _v7782 = v7789 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v7790 : Result<std_path_PathBuf, std_io_Error> = v7779 |> Error
                                                                                                                let _v7782 = v7790 
                                                                                                                #endif
#else
                                                                                                                let v7791 : Result<std_path_PathBuf, std_io_Error> = v7779 |> Error
                                                                                                                let _v7782 = v7791 
                                                                                                                #endif
                                                                                                                let v7792 : Result<std_path_PathBuf, std_io_Error> = _v7782 
                                                                                                                v7792
                                                                                                        | _ ->
                                                                                                            let v7796 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6217} / path': {v6182} / name: {v6218}"
                                                                                                            let v7797 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v7798 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v7799 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7796 v7798 
                                                                                                            let _v7797 = v7799 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v7800 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v7801 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7796 v7800 
                                                                                                            let _v7797 = v7801 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v7802 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v7803 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7796 v7802 
                                                                                                            let _v7797 = v7803 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v7804 : std_io_Error = v7796 
                                                                                                            let _v7797 = v7804 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v7805 : std_io_Error = v7796 
                                                                                                            let _v7797 = v7805 
                                                                                                            #endif
#else
                                                                                                            let v7806 : std_io_Error = v7796 
                                                                                                            let _v7797 = v7806 
                                                                                                            #endif
                                                                                                            let v7807 : std_io_Error = _v7797 
                                                                                                            let v7810 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v7811 : string = "Err($0)"
                                                                                                            let v7812 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7807 v7811 
                                                                                                            let _v7810 = v7812 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v7813 : string = "Err($0)"
                                                                                                            let v7814 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7807 v7813 
                                                                                                            let _v7810 = v7814 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v7815 : string = "Err($0)"
                                                                                                            let v7816 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7807 v7815 
                                                                                                            let _v7810 = v7816 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v7817 : Result<std_path_PathBuf, std_io_Error> = v7807 |> Error
                                                                                                            let _v7810 = v7817 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v7818 : Result<std_path_PathBuf, std_io_Error> = v7807 |> Error
                                                                                                            let _v7810 = v7818 
                                                                                                            #endif
#else
                                                                                                            let v7819 : Result<std_path_PathBuf, std_io_Error> = v7807 |> Error
                                                                                                            let _v7810 = v7819 
                                                                                                            #endif
                                                                                                            let v7820 : Result<std_path_PathBuf, std_io_Error> = _v7810 
                                                                                                            v7820
                                                                                                    | US13_0(v6203) -> (* Ok *)
                                                                                                        let v6204 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v6205 : string = "Ok($0)"
                                                                                                        let v6206 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6203 v6205 
                                                                                                        let _v6204 = v6206 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v6207 : string = "Ok($0)"
                                                                                                        let v6208 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6203 v6207 
                                                                                                        let _v6204 = v6208 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v6209 : string = "Ok($0)"
                                                                                                        let v6210 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6203 v6209 
                                                                                                        let _v6204 = v6210 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v6211 : Result<std_path_PathBuf, std_io_Error> = v6203 |> Ok
                                                                                                        let _v6204 = v6211 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v6212 : Result<std_path_PathBuf, std_io_Error> = v6203 |> Ok
                                                                                                        let _v6204 = v6212 
                                                                                                        #endif
#else
                                                                                                        let v6213 : Result<std_path_PathBuf, std_io_Error> = v6203 |> Ok
                                                                                                        let _v6204 = v6213 
                                                                                                        #endif
                                                                                                        let v6214 : Result<std_path_PathBuf, std_io_Error> = _v6204 
                                                                                                        v6214
                                                                                                let v7826 : (std_io_Error -> string) = method76()
                                                                                                let v7827 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7828 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v7829 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7825, v7826) v7828 
                                                                                                let _v7827 = v7829 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7830 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v7831 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7825, v7826) v7830 
                                                                                                let _v7827 = v7831 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7832 : string = "$0.map_err(|x| $1(x))"
                                                                                                let v7833 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v7825, v7826) v7832 
                                                                                                let _v7827 = v7833 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7834 : Result<std_path_PathBuf, string> = match v7825 with Ok x -> Ok x | Error x -> Error (v7826 x)
                                                                                                let _v7827 = v7834 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7835 : Result<std_path_PathBuf, string> = match v7825 with Ok x -> Ok x | Error x -> Error (v7826 x)
                                                                                                let _v7827 = v7835 
                                                                                                #endif
#else
                                                                                                let v7836 : Result<std_path_PathBuf, string> = match v7825 with Ok x -> Ok x | Error x -> Error (v7826 x)
                                                                                                let _v7827 = v7836 
                                                                                                #endif
                                                                                                let v7837 : Result<std_path_PathBuf, string> = _v7827 
                                                                                                let v7840 : US13 = match v7837 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                                match v7840 with
                                                                                                | US13_1(v7943) -> (* Error *)
                                                                                                    let v7944 : string = $"file_system.read_link / error': {v7943} / error: {v6162} / name: {v6163}"
                                                                                                    let v7945 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v7946 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v7947 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7944 v7946 
                                                                                                    let _v7945 = v7947 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v7948 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v7949 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7944 v7948 
                                                                                                    let _v7945 = v7949 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v7950 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v7951 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7944 v7950 
                                                                                                    let _v7945 = v7951 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v7952 : std_io_Error = v7944 
                                                                                                    let _v7945 = v7952 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v7953 : std_io_Error = v7944 
                                                                                                    let _v7945 = v7953 
                                                                                                    #endif
#else
                                                                                                    let v7954 : std_io_Error = v7944 
                                                                                                    let _v7945 = v7954 
                                                                                                    #endif
                                                                                                    let v7955 : std_io_Error = _v7945 
                                                                                                    let v7958 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v7959 : string = "Err($0)"
                                                                                                    let v7960 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7955 v7959 
                                                                                                    let _v7958 = v7960 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v7961 : string = "Err($0)"
                                                                                                    let v7962 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7955 v7961 
                                                                                                    let _v7958 = v7962 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v7963 : string = "Err($0)"
                                                                                                    let v7964 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7955 v7963 
                                                                                                    let _v7958 = v7964 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v7965 : Result<std_path_PathBuf, std_io_Error> = v7955 |> Error
                                                                                                    let _v7958 = v7965 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v7966 : Result<std_path_PathBuf, std_io_Error> = v7955 |> Error
                                                                                                    let _v7958 = v7966 
                                                                                                    #endif
#else
                                                                                                    let v7967 : Result<std_path_PathBuf, std_io_Error> = v7955 |> Error
                                                                                                    let _v7958 = v7967 
                                                                                                    #endif
                                                                                                    let v7968 : Result<std_path_PathBuf, std_io_Error> = _v7958 
                                                                                                    v7968
                                                                                                | US13_0(v7841) -> (* Ok *)
                                                                                                    let v7842 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v7843 : string = "$0.display()"
                                                                                                    let v7844 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7841 v7843 
                                                                                                    let _v7842 = v7844 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v7845 : string = "$0.display()"
                                                                                                    let v7846 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7841 v7845 
                                                                                                    let _v7842 = v7846 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v7847 : string = "$0.display()"
                                                                                                    let v7848 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v7841 v7847 
                                                                                                    let _v7842 = v7848 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v7849 : std_path_Display = v7841 |> unbox<std_path_Display>
                                                                                                    let _v7842 = v7849 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v7852 : std_path_Display = v7841 |> unbox<std_path_Display>
                                                                                                    let _v7842 = v7852 
                                                                                                    #endif
#else
                                                                                                    let v7855 : std_path_Display = v7841 |> unbox<std_path_Display>
                                                                                                    let _v7842 = v7855 
                                                                                                    #endif
                                                                                                    let v7858 : std_path_Display = _v7842 
                                                                                                    let v7863 : string = v7858 |> string 
                                                                                                    let v7866 : string = method56(v7863, v6163)
                                                                                                    let v7867 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v7868 : string = "&*$0"
                                                                                                    let v7869 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7866 v7868 
                                                                                                    let _v7867 = v7869 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v7870 : string = "&*$0"
                                                                                                    let v7871 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7866 v7870 
                                                                                                    let _v7867 = v7871 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v7872 : string = "&*$0"
                                                                                                    let v7873 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v7866 v7872 
                                                                                                    let _v7867 = v7873 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v7874 : Ref<Str> = v7866 |> unbox<Ref<Str>>
                                                                                                    let _v7867 = v7874 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v7877 : Ref<Str> = v7866 |> unbox<Ref<Str>>
                                                                                                    let _v7867 = v7877 
                                                                                                    #endif
#else
                                                                                                    let v7880 : Ref<Str> = v7866 |> unbox<Ref<Str>>
                                                                                                    let _v7867 = v7880 
                                                                                                    #endif
                                                                                                    let v7883 : Ref<Str> = _v7867 
                                                                                                    let v7888 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v7889 : string = "String::from($0)"
                                                                                                    let v7890 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7883 v7889 
                                                                                                    let _v7888 = v7890 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v7891 : string = "String::from($0)"
                                                                                                    let v7892 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7883 v7891 
                                                                                                    let _v7888 = v7892 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v7893 : string = "String::from($0)"
                                                                                                    let v7894 : std_string_String = Fable.Core.RustInterop.emitRustExpr v7883 v7893 
                                                                                                    let _v7888 = v7894 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v7895 : std_string_String = v7883 |> unbox<std_string_String>
                                                                                                    let _v7888 = v7895 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v7898 : std_string_String = v7883 |> unbox<std_string_String>
                                                                                                    let _v7888 = v7898 
                                                                                                    #endif
#else
                                                                                                    let v7901 : std_string_String = v7883 |> unbox<std_string_String>
                                                                                                    let _v7888 = v7901 
                                                                                                    #endif
                                                                                                    let v7904 : std_string_String = _v7888 
                                                                                                    let v7909 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v7910 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v7911 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7904 v7910 
                                                                                                    let _v7909 = v7911 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v7912 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v7913 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7904 v7912 
                                                                                                    let _v7909 = v7913 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v7914 : string = "std::path::PathBuf::from($0)"
                                                                                                    let v7915 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v7904 v7914 
                                                                                                    let _v7909 = v7915 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v7916 : std_path_PathBuf = v7904 |> std_path_PathBuf 
                                                                                                    let _v7909 = v7916 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v7919 : std_path_PathBuf = v7904 |> std_path_PathBuf 
                                                                                                    let _v7909 = v7919 
                                                                                                    #endif
#else
                                                                                                    let v7922 : std_path_PathBuf = v7904 |> std_path_PathBuf 
                                                                                                    let _v7909 = v7922 
                                                                                                    #endif
                                                                                                    let v7925 : std_path_PathBuf = _v7909 
                                                                                                    let v7930 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v7931 : string = "Ok($0)"
                                                                                                    let v7932 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7925 v7931 
                                                                                                    let _v7930 = v7932 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v7933 : string = "Ok($0)"
                                                                                                    let v7934 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7925 v7933 
                                                                                                    let _v7930 = v7934 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v7935 : string = "Ok($0)"
                                                                                                    let v7936 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7925 v7935 
                                                                                                    let _v7930 = v7936 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v7937 : Result<std_path_PathBuf, std_io_Error> = v7925 |> Ok
                                                                                                    let _v7930 = v7937 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v7938 : Result<std_path_PathBuf, std_io_Error> = v7925 |> Ok
                                                                                                    let _v7930 = v7938 
                                                                                                    #endif
#else
                                                                                                    let v7939 : Result<std_path_PathBuf, std_io_Error> = v7925 |> Ok
                                                                                                    let _v7930 = v7939 
                                                                                                    #endif
                                                                                                    let v7940 : Result<std_path_PathBuf, std_io_Error> = _v7930 
                                                                                                    v7940
                                                                                            else
                                                                                                let v7973 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6162} / path': {v6127} / name: {v6163}"
                                                                                                let v7974 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7975 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v7976 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7973 v7975 
                                                                                                let _v7974 = v7976 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7977 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v7978 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7973 v7977 
                                                                                                let _v7974 = v7978 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7979 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v7980 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v7973 v7979 
                                                                                                let _v7974 = v7980 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7981 : std_io_Error = v7973 
                                                                                                let _v7974 = v7981 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7982 : std_io_Error = v7973 
                                                                                                let _v7974 = v7982 
                                                                                                #endif
#else
                                                                                                let v7983 : std_io_Error = v7973 
                                                                                                let _v7974 = v7983 
                                                                                                #endif
                                                                                                let v7984 : std_io_Error = _v7974 
                                                                                                let v7987 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v7988 : string = "Err($0)"
                                                                                                let v7989 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7984 v7988 
                                                                                                let _v7987 = v7989 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v7990 : string = "Err($0)"
                                                                                                let v7991 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7984 v7990 
                                                                                                let _v7987 = v7991 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v7992 : string = "Err($0)"
                                                                                                let v7993 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v7984 v7992 
                                                                                                let _v7987 = v7993 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v7994 : Result<std_path_PathBuf, std_io_Error> = v7984 |> Error
                                                                                                let _v7987 = v7994 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v7995 : Result<std_path_PathBuf, std_io_Error> = v7984 |> Error
                                                                                                let _v7987 = v7995 
                                                                                                #endif
#else
                                                                                                let v7996 : Result<std_path_PathBuf, std_io_Error> = v7984 |> Error
                                                                                                let _v7987 = v7996 
                                                                                                #endif
                                                                                                let v7997 : Result<std_path_PathBuf, std_io_Error> = _v7987 
                                                                                                v7997
                                                                                        | _ ->
                                                                                            let v8001 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6162} / path': {v6127} / name: {v6163}"
                                                                                            let v8002 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v8003 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v8004 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8001 v8003 
                                                                                            let _v8002 = v8004 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v8005 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v8006 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8001 v8005 
                                                                                            let _v8002 = v8006 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v8007 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v8008 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8001 v8007 
                                                                                            let _v8002 = v8008 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v8009 : std_io_Error = v8001 
                                                                                            let _v8002 = v8009 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v8010 : std_io_Error = v8001 
                                                                                            let _v8002 = v8010 
                                                                                            #endif
#else
                                                                                            let v8011 : std_io_Error = v8001 
                                                                                            let _v8002 = v8011 
                                                                                            #endif
                                                                                            let v8012 : std_io_Error = _v8002 
                                                                                            let v8015 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v8016 : string = "Err($0)"
                                                                                            let v8017 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8012 v8016 
                                                                                            let _v8015 = v8017 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v8018 : string = "Err($0)"
                                                                                            let v8019 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8012 v8018 
                                                                                            let _v8015 = v8019 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v8020 : string = "Err($0)"
                                                                                            let v8021 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8012 v8020 
                                                                                            let _v8015 = v8021 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v8022 : Result<std_path_PathBuf, std_io_Error> = v8012 |> Error
                                                                                            let _v8015 = v8022 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v8023 : Result<std_path_PathBuf, std_io_Error> = v8012 |> Error
                                                                                            let _v8015 = v8023 
                                                                                            #endif
#else
                                                                                            let v8024 : Result<std_path_PathBuf, std_io_Error> = v8012 |> Error
                                                                                            let _v8015 = v8024 
                                                                                            #endif
                                                                                            let v8025 : Result<std_path_PathBuf, std_io_Error> = _v8015 
                                                                                            v8025
                                                                                    | US13_0(v6148) -> (* Ok *)
                                                                                        let v6149 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v6150 : string = "Ok($0)"
                                                                                        let v6151 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6148 v6150 
                                                                                        let _v6149 = v6151 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v6152 : string = "Ok($0)"
                                                                                        let v6153 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6148 v6152 
                                                                                        let _v6149 = v6153 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v6154 : string = "Ok($0)"
                                                                                        let v6155 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6148 v6154 
                                                                                        let _v6149 = v6155 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v6156 : Result<std_path_PathBuf, std_io_Error> = v6148 |> Ok
                                                                                        let _v6149 = v6156 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v6157 : Result<std_path_PathBuf, std_io_Error> = v6148 |> Ok
                                                                                        let _v6149 = v6157 
                                                                                        #endif
#else
                                                                                        let v6158 : Result<std_path_PathBuf, std_io_Error> = v6148 |> Ok
                                                                                        let _v6149 = v6158 
                                                                                        #endif
                                                                                        let v6159 : Result<std_path_PathBuf, std_io_Error> = _v6149 
                                                                                        v6159
                                                                                let v8031 : (std_io_Error -> string) = method76()
                                                                                let v8032 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8033 : string = "$0.map_err(|x| $1(x))"
                                                                                let v8034 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8030, v8031) v8033 
                                                                                let _v8032 = v8034 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8035 : string = "$0.map_err(|x| $1(x))"
                                                                                let v8036 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8030, v8031) v8035 
                                                                                let _v8032 = v8036 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8037 : string = "$0.map_err(|x| $1(x))"
                                                                                let v8038 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8030, v8031) v8037 
                                                                                let _v8032 = v8038 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8039 : Result<std_path_PathBuf, string> = match v8030 with Ok x -> Ok x | Error x -> Error (v8031 x)
                                                                                let _v8032 = v8039 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8040 : Result<std_path_PathBuf, string> = match v8030 with Ok x -> Ok x | Error x -> Error (v8031 x)
                                                                                let _v8032 = v8040 
                                                                                #endif
#else
                                                                                let v8041 : Result<std_path_PathBuf, string> = match v8030 with Ok x -> Ok x | Error x -> Error (v8031 x)
                                                                                let _v8032 = v8041 
                                                                                #endif
                                                                                let v8042 : Result<std_path_PathBuf, string> = _v8032 
                                                                                let v8045 : US13 = match v8042 with Ok x -> v5924 x | Error x -> v5925 x
                                                                                match v8045 with
                                                                                | US13_1(v8148) -> (* Error *)
                                                                                    let v8149 : string = $"file_system.read_link / error': {v8148} / error: {v6107} / name: {v6108}"
                                                                                    let v8150 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v8151 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v8152 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8149 v8151 
                                                                                    let _v8150 = v8152 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v8153 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v8154 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8149 v8153 
                                                                                    let _v8150 = v8154 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v8155 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v8156 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8149 v8155 
                                                                                    let _v8150 = v8156 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v8157 : std_io_Error = v8149 
                                                                                    let _v8150 = v8157 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v8158 : std_io_Error = v8149 
                                                                                    let _v8150 = v8158 
                                                                                    #endif
#else
                                                                                    let v8159 : std_io_Error = v8149 
                                                                                    let _v8150 = v8159 
                                                                                    #endif
                                                                                    let v8160 : std_io_Error = _v8150 
                                                                                    let v8163 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v8164 : string = "Err($0)"
                                                                                    let v8165 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8160 v8164 
                                                                                    let _v8163 = v8165 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v8166 : string = "Err($0)"
                                                                                    let v8167 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8160 v8166 
                                                                                    let _v8163 = v8167 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v8168 : string = "Err($0)"
                                                                                    let v8169 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8160 v8168 
                                                                                    let _v8163 = v8169 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v8170 : Result<std_path_PathBuf, std_io_Error> = v8160 |> Error
                                                                                    let _v8163 = v8170 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v8171 : Result<std_path_PathBuf, std_io_Error> = v8160 |> Error
                                                                                    let _v8163 = v8171 
                                                                                    #endif
#else
                                                                                    let v8172 : Result<std_path_PathBuf, std_io_Error> = v8160 |> Error
                                                                                    let _v8163 = v8172 
                                                                                    #endif
                                                                                    let v8173 : Result<std_path_PathBuf, std_io_Error> = _v8163 
                                                                                    v8173
                                                                                | US13_0(v8046) -> (* Ok *)
                                                                                    let v8047 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v8048 : string = "$0.display()"
                                                                                    let v8049 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8046 v8048 
                                                                                    let _v8047 = v8049 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v8050 : string = "$0.display()"
                                                                                    let v8051 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8046 v8050 
                                                                                    let _v8047 = v8051 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v8052 : string = "$0.display()"
                                                                                    let v8053 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8046 v8052 
                                                                                    let _v8047 = v8053 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v8054 : std_path_Display = v8046 |> unbox<std_path_Display>
                                                                                    let _v8047 = v8054 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v8057 : std_path_Display = v8046 |> unbox<std_path_Display>
                                                                                    let _v8047 = v8057 
                                                                                    #endif
#else
                                                                                    let v8060 : std_path_Display = v8046 |> unbox<std_path_Display>
                                                                                    let _v8047 = v8060 
                                                                                    #endif
                                                                                    let v8063 : std_path_Display = _v8047 
                                                                                    let v8068 : string = v8063 |> string 
                                                                                    let v8071 : string = method56(v8068, v6108)
                                                                                    let v8072 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v8073 : string = "&*$0"
                                                                                    let v8074 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8071 v8073 
                                                                                    let _v8072 = v8074 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v8075 : string = "&*$0"
                                                                                    let v8076 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8071 v8075 
                                                                                    let _v8072 = v8076 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v8077 : string = "&*$0"
                                                                                    let v8078 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8071 v8077 
                                                                                    let _v8072 = v8078 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v8079 : Ref<Str> = v8071 |> unbox<Ref<Str>>
                                                                                    let _v8072 = v8079 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v8082 : Ref<Str> = v8071 |> unbox<Ref<Str>>
                                                                                    let _v8072 = v8082 
                                                                                    #endif
#else
                                                                                    let v8085 : Ref<Str> = v8071 |> unbox<Ref<Str>>
                                                                                    let _v8072 = v8085 
                                                                                    #endif
                                                                                    let v8088 : Ref<Str> = _v8072 
                                                                                    let v8093 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v8094 : string = "String::from($0)"
                                                                                    let v8095 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8088 v8094 
                                                                                    let _v8093 = v8095 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v8096 : string = "String::from($0)"
                                                                                    let v8097 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8088 v8096 
                                                                                    let _v8093 = v8097 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v8098 : string = "String::from($0)"
                                                                                    let v8099 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8088 v8098 
                                                                                    let _v8093 = v8099 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v8100 : std_string_String = v8088 |> unbox<std_string_String>
                                                                                    let _v8093 = v8100 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v8103 : std_string_String = v8088 |> unbox<std_string_String>
                                                                                    let _v8093 = v8103 
                                                                                    #endif
#else
                                                                                    let v8106 : std_string_String = v8088 |> unbox<std_string_String>
                                                                                    let _v8093 = v8106 
                                                                                    #endif
                                                                                    let v8109 : std_string_String = _v8093 
                                                                                    let v8114 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v8115 : string = "std::path::PathBuf::from($0)"
                                                                                    let v8116 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8109 v8115 
                                                                                    let _v8114 = v8116 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v8117 : string = "std::path::PathBuf::from($0)"
                                                                                    let v8118 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8109 v8117 
                                                                                    let _v8114 = v8118 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v8119 : string = "std::path::PathBuf::from($0)"
                                                                                    let v8120 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8109 v8119 
                                                                                    let _v8114 = v8120 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v8121 : std_path_PathBuf = v8109 |> std_path_PathBuf 
                                                                                    let _v8114 = v8121 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v8124 : std_path_PathBuf = v8109 |> std_path_PathBuf 
                                                                                    let _v8114 = v8124 
                                                                                    #endif
#else
                                                                                    let v8127 : std_path_PathBuf = v8109 |> std_path_PathBuf 
                                                                                    let _v8114 = v8127 
                                                                                    #endif
                                                                                    let v8130 : std_path_PathBuf = _v8114 
                                                                                    let v8135 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v8136 : string = "Ok($0)"
                                                                                    let v8137 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8130 v8136 
                                                                                    let _v8135 = v8137 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v8138 : string = "Ok($0)"
                                                                                    let v8139 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8130 v8138 
                                                                                    let _v8135 = v8139 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v8140 : string = "Ok($0)"
                                                                                    let v8141 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8130 v8140 
                                                                                    let _v8135 = v8141 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v8142 : Result<std_path_PathBuf, std_io_Error> = v8130 |> Ok
                                                                                    let _v8135 = v8142 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v8143 : Result<std_path_PathBuf, std_io_Error> = v8130 |> Ok
                                                                                    let _v8135 = v8143 
                                                                                    #endif
#else
                                                                                    let v8144 : Result<std_path_PathBuf, std_io_Error> = v8130 |> Ok
                                                                                    let _v8135 = v8144 
                                                                                    #endif
                                                                                    let v8145 : Result<std_path_PathBuf, std_io_Error> = _v8135 
                                                                                    v8145
                                                                            else
                                                                                let v8178 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6107} / path': {v6072} / name: {v6108}"
                                                                                let v8179 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8180 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v8181 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8178 v8180 
                                                                                let _v8179 = v8181 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8182 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v8183 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8178 v8182 
                                                                                let _v8179 = v8183 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8184 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v8185 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8178 v8184 
                                                                                let _v8179 = v8185 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8186 : std_io_Error = v8178 
                                                                                let _v8179 = v8186 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8187 : std_io_Error = v8178 
                                                                                let _v8179 = v8187 
                                                                                #endif
#else
                                                                                let v8188 : std_io_Error = v8178 
                                                                                let _v8179 = v8188 
                                                                                #endif
                                                                                let v8189 : std_io_Error = _v8179 
                                                                                let v8192 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v8193 : string = "Err($0)"
                                                                                let v8194 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8189 v8193 
                                                                                let _v8192 = v8194 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v8195 : string = "Err($0)"
                                                                                let v8196 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8189 v8195 
                                                                                let _v8192 = v8196 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v8197 : string = "Err($0)"
                                                                                let v8198 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8189 v8197 
                                                                                let _v8192 = v8198 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v8199 : Result<std_path_PathBuf, std_io_Error> = v8189 |> Error
                                                                                let _v8192 = v8199 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v8200 : Result<std_path_PathBuf, std_io_Error> = v8189 |> Error
                                                                                let _v8192 = v8200 
                                                                                #endif
#else
                                                                                let v8201 : Result<std_path_PathBuf, std_io_Error> = v8189 |> Error
                                                                                let _v8192 = v8201 
                                                                                #endif
                                                                                let v8202 : Result<std_path_PathBuf, std_io_Error> = _v8192 
                                                                                v8202
                                                                        | _ ->
                                                                            let v8206 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6107} / path': {v6072} / name: {v6108}"
                                                                            let v8207 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v8208 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v8209 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8206 v8208 
                                                                            let _v8207 = v8209 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v8210 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v8211 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8206 v8210 
                                                                            let _v8207 = v8211 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v8212 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v8213 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8206 v8212 
                                                                            let _v8207 = v8213 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v8214 : std_io_Error = v8206 
                                                                            let _v8207 = v8214 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v8215 : std_io_Error = v8206 
                                                                            let _v8207 = v8215 
                                                                            #endif
#else
                                                                            let v8216 : std_io_Error = v8206 
                                                                            let _v8207 = v8216 
                                                                            #endif
                                                                            let v8217 : std_io_Error = _v8207 
                                                                            let v8220 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v8221 : string = "Err($0)"
                                                                            let v8222 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8217 v8221 
                                                                            let _v8220 = v8222 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v8223 : string = "Err($0)"
                                                                            let v8224 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8217 v8223 
                                                                            let _v8220 = v8224 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v8225 : string = "Err($0)"
                                                                            let v8226 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8217 v8225 
                                                                            let _v8220 = v8226 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v8227 : Result<std_path_PathBuf, std_io_Error> = v8217 |> Error
                                                                            let _v8220 = v8227 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v8228 : Result<std_path_PathBuf, std_io_Error> = v8217 |> Error
                                                                            let _v8220 = v8228 
                                                                            #endif
#else
                                                                            let v8229 : Result<std_path_PathBuf, std_io_Error> = v8217 |> Error
                                                                            let _v8220 = v8229 
                                                                            #endif
                                                                            let v8230 : Result<std_path_PathBuf, std_io_Error> = _v8220 
                                                                            v8230
                                                                    | US13_0(v6093) -> (* Ok *)
                                                                        let v6094 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v6095 : string = "Ok($0)"
                                                                        let v6096 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6093 v6095 
                                                                        let _v6094 = v6096 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v6097 : string = "Ok($0)"
                                                                        let v6098 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6093 v6097 
                                                                        let _v6094 = v6098 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v6099 : string = "Ok($0)"
                                                                        let v6100 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6093 v6099 
                                                                        let _v6094 = v6100 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v6101 : Result<std_path_PathBuf, std_io_Error> = v6093 |> Ok
                                                                        let _v6094 = v6101 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v6102 : Result<std_path_PathBuf, std_io_Error> = v6093 |> Ok
                                                                        let _v6094 = v6102 
                                                                        #endif
#else
                                                                        let v6103 : Result<std_path_PathBuf, std_io_Error> = v6093 |> Ok
                                                                        let _v6094 = v6103 
                                                                        #endif
                                                                        let v6104 : Result<std_path_PathBuf, std_io_Error> = _v6094 
                                                                        v6104
                                                                let v8236 : (std_io_Error -> string) = method76()
                                                                let v8237 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8238 : string = "$0.map_err(|x| $1(x))"
                                                                let v8239 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8235, v8236) v8238 
                                                                let _v8237 = v8239 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8240 : string = "$0.map_err(|x| $1(x))"
                                                                let v8241 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8235, v8236) v8240 
                                                                let _v8237 = v8241 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8242 : string = "$0.map_err(|x| $1(x))"
                                                                let v8243 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8235, v8236) v8242 
                                                                let _v8237 = v8243 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8244 : Result<std_path_PathBuf, string> = match v8235 with Ok x -> Ok x | Error x -> Error (v8236 x)
                                                                let _v8237 = v8244 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8245 : Result<std_path_PathBuf, string> = match v8235 with Ok x -> Ok x | Error x -> Error (v8236 x)
                                                                let _v8237 = v8245 
                                                                #endif
#else
                                                                let v8246 : Result<std_path_PathBuf, string> = match v8235 with Ok x -> Ok x | Error x -> Error (v8236 x)
                                                                let _v8237 = v8246 
                                                                #endif
                                                                let v8247 : Result<std_path_PathBuf, string> = _v8237 
                                                                let v8250 : US13 = match v8247 with Ok x -> v5924 x | Error x -> v5925 x
                                                                match v8250 with
                                                                | US13_1(v8353) -> (* Error *)
                                                                    let v8354 : string = $"file_system.read_link / error': {v8353} / error: {v6052} / name: {v6053}"
                                                                    let v8355 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v8356 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v8357 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8354 v8356 
                                                                    let _v8355 = v8357 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v8358 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v8359 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8354 v8358 
                                                                    let _v8355 = v8359 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v8360 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v8361 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8354 v8360 
                                                                    let _v8355 = v8361 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v8362 : std_io_Error = v8354 
                                                                    let _v8355 = v8362 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v8363 : std_io_Error = v8354 
                                                                    let _v8355 = v8363 
                                                                    #endif
#else
                                                                    let v8364 : std_io_Error = v8354 
                                                                    let _v8355 = v8364 
                                                                    #endif
                                                                    let v8365 : std_io_Error = _v8355 
                                                                    let v8368 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v8369 : string = "Err($0)"
                                                                    let v8370 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8365 v8369 
                                                                    let _v8368 = v8370 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v8371 : string = "Err($0)"
                                                                    let v8372 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8365 v8371 
                                                                    let _v8368 = v8372 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v8373 : string = "Err($0)"
                                                                    let v8374 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8365 v8373 
                                                                    let _v8368 = v8374 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v8375 : Result<std_path_PathBuf, std_io_Error> = v8365 |> Error
                                                                    let _v8368 = v8375 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v8376 : Result<std_path_PathBuf, std_io_Error> = v8365 |> Error
                                                                    let _v8368 = v8376 
                                                                    #endif
#else
                                                                    let v8377 : Result<std_path_PathBuf, std_io_Error> = v8365 |> Error
                                                                    let _v8368 = v8377 
                                                                    #endif
                                                                    let v8378 : Result<std_path_PathBuf, std_io_Error> = _v8368 
                                                                    v8378
                                                                | US13_0(v8251) -> (* Ok *)
                                                                    let v8252 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v8253 : string = "$0.display()"
                                                                    let v8254 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8251 v8253 
                                                                    let _v8252 = v8254 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v8255 : string = "$0.display()"
                                                                    let v8256 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8251 v8255 
                                                                    let _v8252 = v8256 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v8257 : string = "$0.display()"
                                                                    let v8258 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8251 v8257 
                                                                    let _v8252 = v8258 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v8259 : std_path_Display = v8251 |> unbox<std_path_Display>
                                                                    let _v8252 = v8259 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v8262 : std_path_Display = v8251 |> unbox<std_path_Display>
                                                                    let _v8252 = v8262 
                                                                    #endif
#else
                                                                    let v8265 : std_path_Display = v8251 |> unbox<std_path_Display>
                                                                    let _v8252 = v8265 
                                                                    #endif
                                                                    let v8268 : std_path_Display = _v8252 
                                                                    let v8273 : string = v8268 |> string 
                                                                    let v8276 : string = method56(v8273, v6053)
                                                                    let v8277 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v8278 : string = "&*$0"
                                                                    let v8279 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8276 v8278 
                                                                    let _v8277 = v8279 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v8280 : string = "&*$0"
                                                                    let v8281 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8276 v8280 
                                                                    let _v8277 = v8281 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v8282 : string = "&*$0"
                                                                    let v8283 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8276 v8282 
                                                                    let _v8277 = v8283 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v8284 : Ref<Str> = v8276 |> unbox<Ref<Str>>
                                                                    let _v8277 = v8284 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v8287 : Ref<Str> = v8276 |> unbox<Ref<Str>>
                                                                    let _v8277 = v8287 
                                                                    #endif
#else
                                                                    let v8290 : Ref<Str> = v8276 |> unbox<Ref<Str>>
                                                                    let _v8277 = v8290 
                                                                    #endif
                                                                    let v8293 : Ref<Str> = _v8277 
                                                                    let v8298 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v8299 : string = "String::from($0)"
                                                                    let v8300 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8293 v8299 
                                                                    let _v8298 = v8300 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v8301 : string = "String::from($0)"
                                                                    let v8302 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8293 v8301 
                                                                    let _v8298 = v8302 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v8303 : string = "String::from($0)"
                                                                    let v8304 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8293 v8303 
                                                                    let _v8298 = v8304 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v8305 : std_string_String = v8293 |> unbox<std_string_String>
                                                                    let _v8298 = v8305 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v8308 : std_string_String = v8293 |> unbox<std_string_String>
                                                                    let _v8298 = v8308 
                                                                    #endif
#else
                                                                    let v8311 : std_string_String = v8293 |> unbox<std_string_String>
                                                                    let _v8298 = v8311 
                                                                    #endif
                                                                    let v8314 : std_string_String = _v8298 
                                                                    let v8319 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v8320 : string = "std::path::PathBuf::from($0)"
                                                                    let v8321 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8314 v8320 
                                                                    let _v8319 = v8321 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v8322 : string = "std::path::PathBuf::from($0)"
                                                                    let v8323 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8314 v8322 
                                                                    let _v8319 = v8323 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v8324 : string = "std::path::PathBuf::from($0)"
                                                                    let v8325 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8314 v8324 
                                                                    let _v8319 = v8325 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v8326 : std_path_PathBuf = v8314 |> std_path_PathBuf 
                                                                    let _v8319 = v8326 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v8329 : std_path_PathBuf = v8314 |> std_path_PathBuf 
                                                                    let _v8319 = v8329 
                                                                    #endif
#else
                                                                    let v8332 : std_path_PathBuf = v8314 |> std_path_PathBuf 
                                                                    let _v8319 = v8332 
                                                                    #endif
                                                                    let v8335 : std_path_PathBuf = _v8319 
                                                                    let v8340 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v8341 : string = "Ok($0)"
                                                                    let v8342 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8335 v8341 
                                                                    let _v8340 = v8342 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v8343 : string = "Ok($0)"
                                                                    let v8344 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8335 v8343 
                                                                    let _v8340 = v8344 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v8345 : string = "Ok($0)"
                                                                    let v8346 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8335 v8345 
                                                                    let _v8340 = v8346 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v8347 : Result<std_path_PathBuf, std_io_Error> = v8335 |> Ok
                                                                    let _v8340 = v8347 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v8348 : Result<std_path_PathBuf, std_io_Error> = v8335 |> Ok
                                                                    let _v8340 = v8348 
                                                                    #endif
#else
                                                                    let v8349 : Result<std_path_PathBuf, std_io_Error> = v8335 |> Ok
                                                                    let _v8340 = v8349 
                                                                    #endif
                                                                    let v8350 : Result<std_path_PathBuf, std_io_Error> = _v8340 
                                                                    v8350
                                                            else
                                                                let v8383 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6052} / path': {v6017} / name: {v6053}"
                                                                let v8384 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8385 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v8386 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8383 v8385 
                                                                let _v8384 = v8386 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8387 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v8388 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8383 v8387 
                                                                let _v8384 = v8388 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8389 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v8390 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8383 v8389 
                                                                let _v8384 = v8390 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8391 : std_io_Error = v8383 
                                                                let _v8384 = v8391 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8392 : std_io_Error = v8383 
                                                                let _v8384 = v8392 
                                                                #endif
#else
                                                                let v8393 : std_io_Error = v8383 
                                                                let _v8384 = v8393 
                                                                #endif
                                                                let v8394 : std_io_Error = _v8384 
                                                                let v8397 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v8398 : string = "Err($0)"
                                                                let v8399 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8394 v8398 
                                                                let _v8397 = v8399 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v8400 : string = "Err($0)"
                                                                let v8401 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8394 v8400 
                                                                let _v8397 = v8401 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v8402 : string = "Err($0)"
                                                                let v8403 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8394 v8402 
                                                                let _v8397 = v8403 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v8404 : Result<std_path_PathBuf, std_io_Error> = v8394 |> Error
                                                                let _v8397 = v8404 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v8405 : Result<std_path_PathBuf, std_io_Error> = v8394 |> Error
                                                                let _v8397 = v8405 
                                                                #endif
#else
                                                                let v8406 : Result<std_path_PathBuf, std_io_Error> = v8394 |> Error
                                                                let _v8397 = v8406 
                                                                #endif
                                                                let v8407 : Result<std_path_PathBuf, std_io_Error> = _v8397 
                                                                v8407
                                                        | _ ->
                                                            let v8411 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v6052} / path': {v6017} / name: {v6053}"
                                                            let v8412 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v8413 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v8414 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8411 v8413 
                                                            let _v8412 = v8414 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v8415 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v8416 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8411 v8415 
                                                            let _v8412 = v8416 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v8417 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v8418 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8411 v8417 
                                                            let _v8412 = v8418 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v8419 : std_io_Error = v8411 
                                                            let _v8412 = v8419 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v8420 : std_io_Error = v8411 
                                                            let _v8412 = v8420 
                                                            #endif
#else
                                                            let v8421 : std_io_Error = v8411 
                                                            let _v8412 = v8421 
                                                            #endif
                                                            let v8422 : std_io_Error = _v8412 
                                                            let v8425 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v8426 : string = "Err($0)"
                                                            let v8427 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8422 v8426 
                                                            let _v8425 = v8427 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v8428 : string = "Err($0)"
                                                            let v8429 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8422 v8428 
                                                            let _v8425 = v8429 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v8430 : string = "Err($0)"
                                                            let v8431 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8422 v8430 
                                                            let _v8425 = v8431 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v8432 : Result<std_path_PathBuf, std_io_Error> = v8422 |> Error
                                                            let _v8425 = v8432 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v8433 : Result<std_path_PathBuf, std_io_Error> = v8422 |> Error
                                                            let _v8425 = v8433 
                                                            #endif
#else
                                                            let v8434 : Result<std_path_PathBuf, std_io_Error> = v8422 |> Error
                                                            let _v8425 = v8434 
                                                            #endif
                                                            let v8435 : Result<std_path_PathBuf, std_io_Error> = _v8425 
                                                            v8435
                                                    | US13_0(v6038) -> (* Ok *)
                                                        let v6039 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v6040 : string = "Ok($0)"
                                                        let v6041 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6038 v6040 
                                                        let _v6039 = v6041 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v6042 : string = "Ok($0)"
                                                        let v6043 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6038 v6042 
                                                        let _v6039 = v6043 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v6044 : string = "Ok($0)"
                                                        let v6045 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v6038 v6044 
                                                        let _v6039 = v6045 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v6046 : Result<std_path_PathBuf, std_io_Error> = v6038 |> Ok
                                                        let _v6039 = v6046 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v6047 : Result<std_path_PathBuf, std_io_Error> = v6038 |> Ok
                                                        let _v6039 = v6047 
                                                        #endif
#else
                                                        let v6048 : Result<std_path_PathBuf, std_io_Error> = v6038 |> Ok
                                                        let _v6039 = v6048 
                                                        #endif
                                                        let v6049 : Result<std_path_PathBuf, std_io_Error> = _v6039 
                                                        v6049
                                                let v8441 : (std_io_Error -> string) = method76()
                                                let v8442 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8443 : string = "$0.map_err(|x| $1(x))"
                                                let v8444 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8440, v8441) v8443 
                                                let _v8442 = v8444 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8445 : string = "$0.map_err(|x| $1(x))"
                                                let v8446 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8440, v8441) v8445 
                                                let _v8442 = v8446 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8447 : string = "$0.map_err(|x| $1(x))"
                                                let v8448 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8440, v8441) v8447 
                                                let _v8442 = v8448 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8449 : Result<std_path_PathBuf, string> = match v8440 with Ok x -> Ok x | Error x -> Error (v8441 x)
                                                let _v8442 = v8449 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8450 : Result<std_path_PathBuf, string> = match v8440 with Ok x -> Ok x | Error x -> Error (v8441 x)
                                                let _v8442 = v8450 
                                                #endif
#else
                                                let v8451 : Result<std_path_PathBuf, string> = match v8440 with Ok x -> Ok x | Error x -> Error (v8441 x)
                                                let _v8442 = v8451 
                                                #endif
                                                let v8452 : Result<std_path_PathBuf, string> = _v8442 
                                                let v8455 : US13 = match v8452 with Ok x -> v5924 x | Error x -> v5925 x
                                                match v8455 with
                                                | US13_1(v8558) -> (* Error *)
                                                    let v8559 : string = $"file_system.read_link / error': {v8558} / error: {v5997} / name: {v5998}"
                                                    let v8560 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v8561 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v8562 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8559 v8561 
                                                    let _v8560 = v8562 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v8563 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v8564 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8559 v8563 
                                                    let _v8560 = v8564 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v8565 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v8566 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8559 v8565 
                                                    let _v8560 = v8566 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v8567 : std_io_Error = v8559 
                                                    let _v8560 = v8567 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v8568 : std_io_Error = v8559 
                                                    let _v8560 = v8568 
                                                    #endif
#else
                                                    let v8569 : std_io_Error = v8559 
                                                    let _v8560 = v8569 
                                                    #endif
                                                    let v8570 : std_io_Error = _v8560 
                                                    let v8573 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v8574 : string = "Err($0)"
                                                    let v8575 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8570 v8574 
                                                    let _v8573 = v8575 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v8576 : string = "Err($0)"
                                                    let v8577 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8570 v8576 
                                                    let _v8573 = v8577 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v8578 : string = "Err($0)"
                                                    let v8579 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8570 v8578 
                                                    let _v8573 = v8579 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v8580 : Result<std_path_PathBuf, std_io_Error> = v8570 |> Error
                                                    let _v8573 = v8580 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v8581 : Result<std_path_PathBuf, std_io_Error> = v8570 |> Error
                                                    let _v8573 = v8581 
                                                    #endif
#else
                                                    let v8582 : Result<std_path_PathBuf, std_io_Error> = v8570 |> Error
                                                    let _v8573 = v8582 
                                                    #endif
                                                    let v8583 : Result<std_path_PathBuf, std_io_Error> = _v8573 
                                                    v8583
                                                | US13_0(v8456) -> (* Ok *)
                                                    let v8457 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v8458 : string = "$0.display()"
                                                    let v8459 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8456 v8458 
                                                    let _v8457 = v8459 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v8460 : string = "$0.display()"
                                                    let v8461 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8456 v8460 
                                                    let _v8457 = v8461 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v8462 : string = "$0.display()"
                                                    let v8463 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8456 v8462 
                                                    let _v8457 = v8463 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v8464 : std_path_Display = v8456 |> unbox<std_path_Display>
                                                    let _v8457 = v8464 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v8467 : std_path_Display = v8456 |> unbox<std_path_Display>
                                                    let _v8457 = v8467 
                                                    #endif
#else
                                                    let v8470 : std_path_Display = v8456 |> unbox<std_path_Display>
                                                    let _v8457 = v8470 
                                                    #endif
                                                    let v8473 : std_path_Display = _v8457 
                                                    let v8478 : string = v8473 |> string 
                                                    let v8481 : string = method56(v8478, v5998)
                                                    let v8482 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v8483 : string = "&*$0"
                                                    let v8484 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8481 v8483 
                                                    let _v8482 = v8484 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v8485 : string = "&*$0"
                                                    let v8486 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8481 v8485 
                                                    let _v8482 = v8486 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v8487 : string = "&*$0"
                                                    let v8488 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8481 v8487 
                                                    let _v8482 = v8488 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v8489 : Ref<Str> = v8481 |> unbox<Ref<Str>>
                                                    let _v8482 = v8489 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v8492 : Ref<Str> = v8481 |> unbox<Ref<Str>>
                                                    let _v8482 = v8492 
                                                    #endif
#else
                                                    let v8495 : Ref<Str> = v8481 |> unbox<Ref<Str>>
                                                    let _v8482 = v8495 
                                                    #endif
                                                    let v8498 : Ref<Str> = _v8482 
                                                    let v8503 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v8504 : string = "String::from($0)"
                                                    let v8505 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8498 v8504 
                                                    let _v8503 = v8505 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v8506 : string = "String::from($0)"
                                                    let v8507 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8498 v8506 
                                                    let _v8503 = v8507 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v8508 : string = "String::from($0)"
                                                    let v8509 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8498 v8508 
                                                    let _v8503 = v8509 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v8510 : std_string_String = v8498 |> unbox<std_string_String>
                                                    let _v8503 = v8510 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v8513 : std_string_String = v8498 |> unbox<std_string_String>
                                                    let _v8503 = v8513 
                                                    #endif
#else
                                                    let v8516 : std_string_String = v8498 |> unbox<std_string_String>
                                                    let _v8503 = v8516 
                                                    #endif
                                                    let v8519 : std_string_String = _v8503 
                                                    let v8524 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v8525 : string = "std::path::PathBuf::from($0)"
                                                    let v8526 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8519 v8525 
                                                    let _v8524 = v8526 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v8527 : string = "std::path::PathBuf::from($0)"
                                                    let v8528 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8519 v8527 
                                                    let _v8524 = v8528 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v8529 : string = "std::path::PathBuf::from($0)"
                                                    let v8530 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8519 v8529 
                                                    let _v8524 = v8530 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v8531 : std_path_PathBuf = v8519 |> std_path_PathBuf 
                                                    let _v8524 = v8531 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v8534 : std_path_PathBuf = v8519 |> std_path_PathBuf 
                                                    let _v8524 = v8534 
                                                    #endif
#else
                                                    let v8537 : std_path_PathBuf = v8519 |> std_path_PathBuf 
                                                    let _v8524 = v8537 
                                                    #endif
                                                    let v8540 : std_path_PathBuf = _v8524 
                                                    let v8545 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v8546 : string = "Ok($0)"
                                                    let v8547 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8540 v8546 
                                                    let _v8545 = v8547 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v8548 : string = "Ok($0)"
                                                    let v8549 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8540 v8548 
                                                    let _v8545 = v8549 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v8550 : string = "Ok($0)"
                                                    let v8551 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8540 v8550 
                                                    let _v8545 = v8551 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v8552 : Result<std_path_PathBuf, std_io_Error> = v8540 |> Ok
                                                    let _v8545 = v8552 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v8553 : Result<std_path_PathBuf, std_io_Error> = v8540 |> Ok
                                                    let _v8545 = v8553 
                                                    #endif
#else
                                                    let v8554 : Result<std_path_PathBuf, std_io_Error> = v8540 |> Ok
                                                    let _v8545 = v8554 
                                                    #endif
                                                    let v8555 : Result<std_path_PathBuf, std_io_Error> = _v8545 
                                                    v8555
                                            else
                                                let v8588 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v5997} / path': {v5961} / name: {v5998}"
                                                let v8589 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8590 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v8591 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8588 v8590 
                                                let _v8589 = v8591 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8592 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v8593 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8588 v8592 
                                                let _v8589 = v8593 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8594 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v8595 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8588 v8594 
                                                let _v8589 = v8595 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8596 : std_io_Error = v8588 
                                                let _v8589 = v8596 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8597 : std_io_Error = v8588 
                                                let _v8589 = v8597 
                                                #endif
#else
                                                let v8598 : std_io_Error = v8588 
                                                let _v8589 = v8598 
                                                #endif
                                                let v8599 : std_io_Error = _v8589 
                                                let v8602 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v8603 : string = "Err($0)"
                                                let v8604 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8599 v8603 
                                                let _v8602 = v8604 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v8605 : string = "Err($0)"
                                                let v8606 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8599 v8605 
                                                let _v8602 = v8606 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v8607 : string = "Err($0)"
                                                let v8608 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8599 v8607 
                                                let _v8602 = v8608 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v8609 : Result<std_path_PathBuf, std_io_Error> = v8599 |> Error
                                                let _v8602 = v8609 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v8610 : Result<std_path_PathBuf, std_io_Error> = v8599 |> Error
                                                let _v8602 = v8610 
                                                #endif
#else
                                                let v8611 : Result<std_path_PathBuf, std_io_Error> = v8599 |> Error
                                                let _v8602 = v8611 
                                                #endif
                                                let v8612 : Result<std_path_PathBuf, std_io_Error> = _v8602 
                                                v8612
                                        | _ ->
                                            let v8616 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v5997} / path': {v5961} / name: {v5998}"
                                            let v8617 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v8618 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v8619 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8616 v8618 
                                            let _v8617 = v8619 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v8620 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v8621 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8616 v8620 
                                            let _v8617 = v8621 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v8622 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v8623 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8616 v8622 
                                            let _v8617 = v8623 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v8624 : std_io_Error = v8616 
                                            let _v8617 = v8624 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v8625 : std_io_Error = v8616 
                                            let _v8617 = v8625 
                                            #endif
#else
                                            let v8626 : std_io_Error = v8616 
                                            let _v8617 = v8626 
                                            #endif
                                            let v8627 : std_io_Error = _v8617 
                                            let v8630 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v8631 : string = "Err($0)"
                                            let v8632 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8627 v8631 
                                            let _v8630 = v8632 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v8633 : string = "Err($0)"
                                            let v8634 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8627 v8633 
                                            let _v8630 = v8634 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v8635 : string = "Err($0)"
                                            let v8636 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8627 v8635 
                                            let _v8630 = v8636 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v8637 : Result<std_path_PathBuf, std_io_Error> = v8627 |> Error
                                            let _v8630 = v8637 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v8638 : Result<std_path_PathBuf, std_io_Error> = v8627 |> Error
                                            let _v8630 = v8638 
                                            #endif
#else
                                            let v8639 : Result<std_path_PathBuf, std_io_Error> = v8627 |> Error
                                            let _v8630 = v8639 
                                            #endif
                                            let v8640 : Result<std_path_PathBuf, std_io_Error> = _v8630 
                                            v8640
                                    | US13_0(v5983) -> (* Ok *)
                                        let v5984 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v5985 : string = "Ok($0)"
                                        let v5986 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5983 v5985 
                                        let _v5984 = v5986 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v5987 : string = "Ok($0)"
                                        let v5988 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5983 v5987 
                                        let _v5984 = v5988 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v5989 : string = "Ok($0)"
                                        let v5990 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5983 v5989 
                                        let _v5984 = v5990 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v5991 : Result<std_path_PathBuf, std_io_Error> = v5983 |> Ok
                                        let _v5984 = v5991 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v5992 : Result<std_path_PathBuf, std_io_Error> = v5983 |> Ok
                                        let _v5984 = v5992 
                                        #endif
#else
                                        let v5993 : Result<std_path_PathBuf, std_io_Error> = v5983 |> Ok
                                        let _v5984 = v5993 
                                        #endif
                                        let v5994 : Result<std_path_PathBuf, std_io_Error> = _v5984 
                                        v5994
                                let v8646 : (std_io_Error -> string) = method76()
                                let v8647 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8648 : string = "$0.map_err(|x| $1(x))"
                                let v8649 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8645, v8646) v8648 
                                let _v8647 = v8649 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8650 : string = "$0.map_err(|x| $1(x))"
                                let v8651 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8645, v8646) v8650 
                                let _v8647 = v8651 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8652 : string = "$0.map_err(|x| $1(x))"
                                let v8653 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v8645, v8646) v8652 
                                let _v8647 = v8653 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8654 : Result<std_path_PathBuf, string> = match v8645 with Ok x -> Ok x | Error x -> Error (v8646 x)
                                let _v8647 = v8654 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8655 : Result<std_path_PathBuf, string> = match v8645 with Ok x -> Ok x | Error x -> Error (v8646 x)
                                let _v8647 = v8655 
                                #endif
#else
                                let v8656 : Result<std_path_PathBuf, string> = match v8645 with Ok x -> Ok x | Error x -> Error (v8646 x)
                                let _v8647 = v8656 
                                #endif
                                let v8657 : Result<std_path_PathBuf, string> = _v8647 
                                let v8660 : US13 = match v8657 with Ok x -> v5924 x | Error x -> v5925 x
                                match v8660 with
                                | US13_1(v8763) -> (* Error *)
                                    let v8764 : string = $"file_system.read_link / error': {v8763} / error: {v5941} / name: {v5942}"
                                    let v8765 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v8766 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v8767 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8764 v8766 
                                    let _v8765 = v8767 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v8768 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v8769 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8764 v8768 
                                    let _v8765 = v8769 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v8770 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v8771 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8764 v8770 
                                    let _v8765 = v8771 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v8772 : std_io_Error = v8764 
                                    let _v8765 = v8772 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v8773 : std_io_Error = v8764 
                                    let _v8765 = v8773 
                                    #endif
#else
                                    let v8774 : std_io_Error = v8764 
                                    let _v8765 = v8774 
                                    #endif
                                    let v8775 : std_io_Error = _v8765 
                                    let v8778 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v8779 : string = "Err($0)"
                                    let v8780 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8775 v8779 
                                    let _v8778 = v8780 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v8781 : string = "Err($0)"
                                    let v8782 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8775 v8781 
                                    let _v8778 = v8782 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v8783 : string = "Err($0)"
                                    let v8784 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8775 v8783 
                                    let _v8778 = v8784 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v8785 : Result<std_path_PathBuf, std_io_Error> = v8775 |> Error
                                    let _v8778 = v8785 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v8786 : Result<std_path_PathBuf, std_io_Error> = v8775 |> Error
                                    let _v8778 = v8786 
                                    #endif
#else
                                    let v8787 : Result<std_path_PathBuf, std_io_Error> = v8775 |> Error
                                    let _v8778 = v8787 
                                    #endif
                                    let v8788 : Result<std_path_PathBuf, std_io_Error> = _v8778 
                                    v8788
                                | US13_0(v8661) -> (* Ok *)
                                    let v8662 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v8663 : string = "$0.display()"
                                    let v8664 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8661 v8663 
                                    let _v8662 = v8664 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v8665 : string = "$0.display()"
                                    let v8666 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8661 v8665 
                                    let _v8662 = v8666 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v8667 : string = "$0.display()"
                                    let v8668 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v8661 v8667 
                                    let _v8662 = v8668 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v8669 : std_path_Display = v8661 |> unbox<std_path_Display>
                                    let _v8662 = v8669 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v8672 : std_path_Display = v8661 |> unbox<std_path_Display>
                                    let _v8662 = v8672 
                                    #endif
#else
                                    let v8675 : std_path_Display = v8661 |> unbox<std_path_Display>
                                    let _v8662 = v8675 
                                    #endif
                                    let v8678 : std_path_Display = _v8662 
                                    let v8683 : string = v8678 |> string 
                                    let v8686 : string = method56(v8683, v5942)
                                    let v8687 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v8688 : string = "&*$0"
                                    let v8689 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8686 v8688 
                                    let _v8687 = v8689 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v8690 : string = "&*$0"
                                    let v8691 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8686 v8690 
                                    let _v8687 = v8691 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v8692 : string = "&*$0"
                                    let v8693 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v8686 v8692 
                                    let _v8687 = v8693 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v8694 : Ref<Str> = v8686 |> unbox<Ref<Str>>
                                    let _v8687 = v8694 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v8697 : Ref<Str> = v8686 |> unbox<Ref<Str>>
                                    let _v8687 = v8697 
                                    #endif
#else
                                    let v8700 : Ref<Str> = v8686 |> unbox<Ref<Str>>
                                    let _v8687 = v8700 
                                    #endif
                                    let v8703 : Ref<Str> = _v8687 
                                    let v8708 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v8709 : string = "String::from($0)"
                                    let v8710 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8703 v8709 
                                    let _v8708 = v8710 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v8711 : string = "String::from($0)"
                                    let v8712 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8703 v8711 
                                    let _v8708 = v8712 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v8713 : string = "String::from($0)"
                                    let v8714 : std_string_String = Fable.Core.RustInterop.emitRustExpr v8703 v8713 
                                    let _v8708 = v8714 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v8715 : std_string_String = v8703 |> unbox<std_string_String>
                                    let _v8708 = v8715 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v8718 : std_string_String = v8703 |> unbox<std_string_String>
                                    let _v8708 = v8718 
                                    #endif
#else
                                    let v8721 : std_string_String = v8703 |> unbox<std_string_String>
                                    let _v8708 = v8721 
                                    #endif
                                    let v8724 : std_string_String = _v8708 
                                    let v8729 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v8730 : string = "std::path::PathBuf::from($0)"
                                    let v8731 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8724 v8730 
                                    let _v8729 = v8731 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v8732 : string = "std::path::PathBuf::from($0)"
                                    let v8733 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8724 v8732 
                                    let _v8729 = v8733 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v8734 : string = "std::path::PathBuf::from($0)"
                                    let v8735 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v8724 v8734 
                                    let _v8729 = v8735 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v8736 : std_path_PathBuf = v8724 |> std_path_PathBuf 
                                    let _v8729 = v8736 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v8739 : std_path_PathBuf = v8724 |> std_path_PathBuf 
                                    let _v8729 = v8739 
                                    #endif
#else
                                    let v8742 : std_path_PathBuf = v8724 |> std_path_PathBuf 
                                    let _v8729 = v8742 
                                    #endif
                                    let v8745 : std_path_PathBuf = _v8729 
                                    let v8750 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v8751 : string = "Ok($0)"
                                    let v8752 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8745 v8751 
                                    let _v8750 = v8752 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v8753 : string = "Ok($0)"
                                    let v8754 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8745 v8753 
                                    let _v8750 = v8754 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v8755 : string = "Ok($0)"
                                    let v8756 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8745 v8755 
                                    let _v8750 = v8756 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v8757 : Result<std_path_PathBuf, std_io_Error> = v8745 |> Ok
                                    let _v8750 = v8757 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v8758 : Result<std_path_PathBuf, std_io_Error> = v8745 |> Ok
                                    let _v8750 = v8758 
                                    #endif
#else
                                    let v8759 : Result<std_path_PathBuf, std_io_Error> = v8745 |> Ok
                                    let _v8750 = v8759 
                                    #endif
                                    let v8760 : Result<std_path_PathBuf, std_io_Error> = _v8750 
                                    v8760
                            else
                                let v8793 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v5941} / path': {v1} / name: {v5942}"
                                let v8794 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8795 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v8796 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8793 v8795 
                                let _v8794 = v8796 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8797 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v8798 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8793 v8797 
                                let _v8794 = v8798 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8799 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v8800 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8793 v8799 
                                let _v8794 = v8800 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8801 : std_io_Error = v8793 
                                let _v8794 = v8801 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8802 : std_io_Error = v8793 
                                let _v8794 = v8802 
                                #endif
#else
                                let v8803 : std_io_Error = v8793 
                                let _v8794 = v8803 
                                #endif
                                let v8804 : std_io_Error = _v8794 
                                let v8807 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v8808 : string = "Err($0)"
                                let v8809 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8804 v8808 
                                let _v8807 = v8809 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v8810 : string = "Err($0)"
                                let v8811 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8804 v8810 
                                let _v8807 = v8811 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v8812 : string = "Err($0)"
                                let v8813 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8804 v8812 
                                let _v8807 = v8813 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v8814 : Result<std_path_PathBuf, std_io_Error> = v8804 |> Error
                                let _v8807 = v8814 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v8815 : Result<std_path_PathBuf, std_io_Error> = v8804 |> Error
                                let _v8807 = v8815 
                                #endif
#else
                                let v8816 : Result<std_path_PathBuf, std_io_Error> = v8804 |> Error
                                let _v8807 = v8816 
                                #endif
                                let v8817 : Result<std_path_PathBuf, std_io_Error> = _v8807 
                                v8817
                        | _ ->
                            let v8821 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v5941} / path': {v1} / name: {v5942}"
                            let v8822 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v8823 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v8824 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8821 v8823 
                            let _v8822 = v8824 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v8825 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v8826 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8821 v8825 
                            let _v8822 = v8826 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v8827 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v8828 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8821 v8827 
                            let _v8822 = v8828 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v8829 : std_io_Error = v8821 
                            let _v8822 = v8829 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v8830 : std_io_Error = v8821 
                            let _v8822 = v8830 
                            #endif
#else
                            let v8831 : std_io_Error = v8821 
                            let _v8822 = v8831 
                            #endif
                            let v8832 : std_io_Error = _v8822 
                            let v8835 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v8836 : string = "Err($0)"
                            let v8837 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8832 v8836 
                            let _v8835 = v8837 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v8838 : string = "Err($0)"
                            let v8839 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8832 v8838 
                            let _v8835 = v8839 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v8840 : string = "Err($0)"
                            let v8841 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8832 v8840 
                            let _v8835 = v8841 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v8842 : Result<std_path_PathBuf, std_io_Error> = v8832 |> Error
                            let _v8835 = v8842 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v8843 : Result<std_path_PathBuf, std_io_Error> = v8832 |> Error
                            let _v8835 = v8843 
                            #endif
#else
                            let v8844 : Result<std_path_PathBuf, std_io_Error> = v8832 |> Error
                            let _v8835 = v8844 
                            #endif
                            let v8845 : Result<std_path_PathBuf, std_io_Error> = _v8835 
                            v8845
                    | US13_0(v5927) -> (* Ok *)
                        let v5928 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v5929 : string = "Ok($0)"
                        let v5930 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5927 v5929 
                        let _v5928 = v5930 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v5931 : string = "Ok($0)"
                        let v5932 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5927 v5931 
                        let _v5928 = v5932 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v5933 : string = "Ok($0)"
                        let v5934 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v5927 v5933 
                        let _v5928 = v5934 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v5935 : Result<std_path_PathBuf, std_io_Error> = v5927 |> Ok
                        let _v5928 = v5935 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v5936 : Result<std_path_PathBuf, std_io_Error> = v5927 |> Ok
                        let _v5928 = v5936 
                        #endif
#else
                        let v5937 : Result<std_path_PathBuf, std_io_Error> = v5927 |> Ok
                        let _v5928 = v5937 
                        #endif
                        let v5938 : Result<std_path_PathBuf, std_io_Error> = _v5928 
                        v5938
            let _v10 = v8851 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v8852 : Result<std_path_PathBuf, std_io_Error> = null |> unbox<Result<std_path_PathBuf, std_io_Error>>
            let _v10 = v8852 
            #endif
#if FABLE_COMPILER_PYTHON
            let v8855 : Result<std_path_PathBuf, std_io_Error> = Unchecked.defaultof<_>
            let _v10 = v8855 
            #endif
#else
            let v8856 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
            let v8857 : System.IO.DirectoryInfo = v8856 v1
            let v8858 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v8859 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8858 = v8859 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v8862 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8858 = v8862 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v8865 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8858 = v8865 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v8868 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8858 = v8868 
            #endif
#if FABLE_COMPILER_PYTHON
            let v8871 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8858 = v8871 
            #endif
#else
            let v8874 : System.IO.FileAttributes = v8857.Attributes
            let _v8858 = v8874 
            #endif
            let v8875 : System.IO.FileAttributes = _v8858 
            let v8880 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v8881 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8880 = v8881 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v8884 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8880 = v8884 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v8887 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8880 = v8887 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v8890 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8880 = v8890 
            #endif
#if FABLE_COMPILER_PYTHON
            let v8893 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
            let _v8880 = v8893 
            #endif
#else
            let v8896 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
            let _v8880 = v8896 
            #endif
            let v8897 : System.IO.FileAttributes = _v8880 
            let v8902 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v8903 : bool = null |> unbox<bool>
            let _v8902 = v8903 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v8906 : bool = null |> unbox<bool>
            let _v8902 = v8906 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v8909 : bool = null |> unbox<bool>
            let _v8902 = v8909 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let v8912 : bool = null |> unbox<bool>
            let _v8902 = v8912 
            #endif
#if FABLE_COMPILER_PYTHON
            let v8915 : bool = null |> unbox<bool>
            let _v8902 = v8915 
            #endif
#else
            let v8918 : bool = v8875.HasFlag v8897 
            let _v8902 = v8918 
            #endif
            let v8919 : bool = _v8902 
            let v13138 : Result<std_path_PathBuf, std_io_Error> =
                if v8919 then
                    let v8924 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v8925 : file_info = null |> unbox<file_info>
                    let _v8924 = v8925 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v8928 : file_info = null |> unbox<file_info>
                    let _v8924 = v8928 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v8931 : file_info = null |> unbox<file_info>
                    let _v8924 = v8931 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v8934 : file_info = null |> unbox<file_info>
                    let _v8924 = v8934 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v8937 : file_info = null |> unbox<file_info>
                    let _v8924 = v8937 
                    #endif
#else
                    let v8940 : (string -> file_info) = file_info 
                    let v8941 : file_info = v8940 v1
                    let _v8924 = v8941 
                    #endif
                    let v8942 : file_info = _v8924 
                    let v8947 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v8948 : string = null |> unbox<string>
                    let _v8947 = v8948 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v8951 : string = null |> unbox<string>
                    let _v8947 = v8951 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v8954 : string = null |> unbox<string>
                    let _v8947 = v8954 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v8957 : string = null |> unbox<string>
                    let _v8947 = v8957 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v8960 : string = null |> unbox<string>
                    let _v8947 = v8960 
                    #endif
#else
                    let v8963 : string = v8942.LinkTarget
                    let _v8947 = v8963 
                    #endif
                    let v8964 : string = _v8947 
                    let v8969 : std_path_PathBuf = v8964 |> std_path_PathBuf 
                    let v8972 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v8973 : string = "Ok($0)"
                    let v8974 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8969 v8973 
                    let _v8972 = v8974 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v8975 : string = "Ok($0)"
                    let v8976 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8969 v8975 
                    let _v8972 = v8976 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v8977 : string = "Ok($0)"
                    let v8978 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v8969 v8977 
                    let _v8972 = v8978 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v8979 : Result<std_path_PathBuf, std_io_Error> = v8969 |> Ok
                    let _v8972 = v8979 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v8980 : Result<std_path_PathBuf, std_io_Error> = v8969 |> Ok
                    let _v8972 = v8980 
                    #endif
#else
                    let v8981 : Result<std_path_PathBuf, std_io_Error> = v8969 |> Ok
                    let _v8972 = v8981 
                    #endif
                    let v8982 : Result<std_path_PathBuf, std_io_Error> = _v8972 
                    v8982
                else
                    let v8985 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v8919} / path': {v1} / n: {0uy}"
                    let v8986 : unit = ()
                    
#if FABLE_COMPILER || WASM || CONTRACT
                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                    let v8987 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                    let v8988 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8985 v8987 
                    let _v8986 = v8988 
                    #endif
#if FABLE_COMPILER_RUST && WASM
                    let v8989 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                    let v8990 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8985 v8989 
                    let _v8986 = v8990 
                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                    let v8991 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                    let v8992 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v8985 v8991 
                    let _v8986 = v8992 
                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                    let v8993 : std_io_Error = v8985 
                    let _v8986 = v8993 
                    #endif
#if FABLE_COMPILER_PYTHON
                    let v8994 : std_io_Error = v8985 
                    let _v8986 = v8994 
                    #endif
#else
                    let v8995 : std_io_Error = v8985 
                    let _v8986 = v8995 
                    #endif
                    let v8996 : std_io_Error = _v8986 
                    let v8999 : string = method19(v1)
                    let v9000 : string option = method78(v1)
                    let v9001 : (string -> US1) = method4()
                    let v9002 : US1 option = v9000 |> Option.map v9001 
                    let v9013 : US1 = US1_1
                    let v9014 : US1 = v9002 |> Option.defaultValue v9013 
                    match v9014 with
                    | US1_0(v9018) -> (* Some *)
                        let v9019 : string = ""
                        let v9020 : bool = v1 <> v9019 
                        if v9020 then
                            let v9023 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                            let v9024 : System.IO.DirectoryInfo = v9023 v9018
                            let v9025 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v9026 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9025 = v9026 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v9029 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9025 = v9029 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v9032 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9025 = v9032 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v9035 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9025 = v9035 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v9038 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9025 = v9038 
                            #endif
#else
                            let v9041 : System.IO.FileAttributes = v9024.Attributes
                            let _v9025 = v9041 
                            #endif
                            let v9042 : System.IO.FileAttributes = _v9025 
                            let v9047 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v9048 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9047 = v9048 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v9051 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9047 = v9051 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v9054 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9047 = v9054 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v9057 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9047 = v9057 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v9060 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                            let _v9047 = v9060 
                            #endif
#else
                            let v9063 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                            let _v9047 = v9063 
                            #endif
                            let v9064 : System.IO.FileAttributes = _v9047 
                            let v9069 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v9070 : bool = null |> unbox<bool>
                            let _v9069 = v9070 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v9073 : bool = null |> unbox<bool>
                            let _v9069 = v9073 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v9076 : bool = null |> unbox<bool>
                            let _v9069 = v9076 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v9079 : bool = null |> unbox<bool>
                            let _v9069 = v9079 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v9082 : bool = null |> unbox<bool>
                            let _v9069 = v9082 
                            #endif
#else
                            let v9085 : bool = v9042.HasFlag v9064 
                            let _v9069 = v9085 
                            #endif
                            let v9086 : bool = _v9069 
                            let v12932 : Result<std_path_PathBuf, std_io_Error> =
                                if v9086 then
                                    let v9091 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v9092 : file_info = null |> unbox<file_info>
                                    let _v9091 = v9092 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v9095 : file_info = null |> unbox<file_info>
                                    let _v9091 = v9095 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v9098 : file_info = null |> unbox<file_info>
                                    let _v9091 = v9098 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v9101 : file_info = null |> unbox<file_info>
                                    let _v9091 = v9101 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v9104 : file_info = null |> unbox<file_info>
                                    let _v9091 = v9104 
                                    #endif
#else
                                    let v9107 : (string -> file_info) = file_info 
                                    let v9108 : file_info = v9107 v9018
                                    let _v9091 = v9108 
                                    #endif
                                    let v9109 : file_info = _v9091 
                                    let v9114 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v9115 : string = null |> unbox<string>
                                    let _v9114 = v9115 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v9118 : string = null |> unbox<string>
                                    let _v9114 = v9118 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v9121 : string = null |> unbox<string>
                                    let _v9114 = v9121 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v9124 : string = null |> unbox<string>
                                    let _v9114 = v9124 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v9127 : string = null |> unbox<string>
                                    let _v9114 = v9127 
                                    #endif
#else
                                    let v9130 : string = v9109.LinkTarget
                                    let _v9114 = v9130 
                                    #endif
                                    let v9131 : string = _v9114 
                                    let v9136 : std_path_PathBuf = v9131 |> std_path_PathBuf 
                                    let v9139 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v9140 : string = "Ok($0)"
                                    let v9141 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9136 v9140 
                                    let _v9139 = v9141 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v9142 : string = "Ok($0)"
                                    let v9143 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9136 v9142 
                                    let _v9139 = v9143 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v9144 : string = "Ok($0)"
                                    let v9145 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9136 v9144 
                                    let _v9139 = v9145 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v9146 : Result<std_path_PathBuf, std_io_Error> = v9136 |> Ok
                                    let _v9139 = v9146 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v9147 : Result<std_path_PathBuf, std_io_Error> = v9136 |> Ok
                                    let _v9139 = v9147 
                                    #endif
#else
                                    let v9148 : Result<std_path_PathBuf, std_io_Error> = v9136 |> Ok
                                    let _v9139 = v9148 
                                    #endif
                                    let v9149 : Result<std_path_PathBuf, std_io_Error> = _v9139 
                                    v9149
                                else
                                    let v9152 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v9086} / path': {v9018} / n: {1uy}"
                                    let v9153 : unit = ()
                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                    let v9154 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v9155 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9152 v9154 
                                    let _v9153 = v9155 
                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                    let v9156 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v9157 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9152 v9156 
                                    let _v9153 = v9157 
                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                    let v9158 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                    let v9159 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9152 v9158 
                                    let _v9153 = v9159 
                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                    let v9160 : std_io_Error = v9152 
                                    let _v9153 = v9160 
                                    #endif
#if FABLE_COMPILER_PYTHON
                                    let v9161 : std_io_Error = v9152 
                                    let _v9153 = v9161 
                                    #endif
#else
                                    let v9162 : std_io_Error = v9152 
                                    let _v9153 = v9162 
                                    #endif
                                    let v9163 : std_io_Error = _v9153 
                                    let v9166 : string = method19(v9018)
                                    let v9167 : string option = method78(v9018)
                                    let v9168 : (string -> US1) = method4()
                                    let v9169 : US1 option = v9167 |> Option.map v9168 
                                    let v9180 : US1 = US1_1
                                    let v9181 : US1 = v9169 |> Option.defaultValue v9180 
                                    match v9181 with
                                    | US1_0(v9185) -> (* Some *)
                                        let v9186 : bool = v9018 <> v9019 
                                        if v9186 then
                                            let v9189 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                            let v9190 : System.IO.DirectoryInfo = v9189 v9185
                                            let v9191 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v9192 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9191 = v9192 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v9195 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9191 = v9195 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v9198 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9191 = v9198 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v9201 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9191 = v9201 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v9204 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9191 = v9204 
                                            #endif
#else
                                            let v9207 : System.IO.FileAttributes = v9190.Attributes
                                            let _v9191 = v9207 
                                            #endif
                                            let v9208 : System.IO.FileAttributes = _v9191 
                                            let v9213 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v9214 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9213 = v9214 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v9217 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9213 = v9217 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v9220 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9213 = v9220 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v9223 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9213 = v9223 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v9226 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                            let _v9213 = v9226 
                                            #endif
#else
                                            let v9229 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                            let _v9213 = v9229 
                                            #endif
                                            let v9230 : System.IO.FileAttributes = _v9213 
                                            let v9235 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v9236 : bool = null |> unbox<bool>
                                            let _v9235 = v9236 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v9239 : bool = null |> unbox<bool>
                                            let _v9235 = v9239 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v9242 : bool = null |> unbox<bool>
                                            let _v9235 = v9242 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v9245 : bool = null |> unbox<bool>
                                            let _v9235 = v9245 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v9248 : bool = null |> unbox<bool>
                                            let _v9235 = v9248 
                                            #endif
#else
                                            let v9251 : bool = v9208.HasFlag v9230 
                                            let _v9235 = v9251 
                                            #endif
                                            let v9252 : bool = _v9235 
                                            let v12726 : Result<std_path_PathBuf, std_io_Error> =
                                                if v9252 then
                                                    let v9257 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v9258 : file_info = null |> unbox<file_info>
                                                    let _v9257 = v9258 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v9261 : file_info = null |> unbox<file_info>
                                                    let _v9257 = v9261 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v9264 : file_info = null |> unbox<file_info>
                                                    let _v9257 = v9264 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v9267 : file_info = null |> unbox<file_info>
                                                    let _v9257 = v9267 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v9270 : file_info = null |> unbox<file_info>
                                                    let _v9257 = v9270 
                                                    #endif
#else
                                                    let v9273 : (string -> file_info) = file_info 
                                                    let v9274 : file_info = v9273 v9185
                                                    let _v9257 = v9274 
                                                    #endif
                                                    let v9275 : file_info = _v9257 
                                                    let v9280 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v9281 : string = null |> unbox<string>
                                                    let _v9280 = v9281 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v9284 : string = null |> unbox<string>
                                                    let _v9280 = v9284 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v9287 : string = null |> unbox<string>
                                                    let _v9280 = v9287 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v9290 : string = null |> unbox<string>
                                                    let _v9280 = v9290 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v9293 : string = null |> unbox<string>
                                                    let _v9280 = v9293 
                                                    #endif
#else
                                                    let v9296 : string = v9275.LinkTarget
                                                    let _v9280 = v9296 
                                                    #endif
                                                    let v9297 : string = _v9280 
                                                    let v9302 : std_path_PathBuf = v9297 |> std_path_PathBuf 
                                                    let v9305 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v9306 : string = "Ok($0)"
                                                    let v9307 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9302 v9306 
                                                    let _v9305 = v9307 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v9308 : string = "Ok($0)"
                                                    let v9309 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9302 v9308 
                                                    let _v9305 = v9309 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v9310 : string = "Ok($0)"
                                                    let v9311 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9302 v9310 
                                                    let _v9305 = v9311 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v9312 : Result<std_path_PathBuf, std_io_Error> = v9302 |> Ok
                                                    let _v9305 = v9312 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v9313 : Result<std_path_PathBuf, std_io_Error> = v9302 |> Ok
                                                    let _v9305 = v9313 
                                                    #endif
#else
                                                    let v9314 : Result<std_path_PathBuf, std_io_Error> = v9302 |> Ok
                                                    let _v9305 = v9314 
                                                    #endif
                                                    let v9315 : Result<std_path_PathBuf, std_io_Error> = _v9305 
                                                    v9315
                                                else
                                                    let v9318 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v9252} / path': {v9185} / n: {2uy}"
                                                    let v9319 : unit = ()
                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                    let v9320 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v9321 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9318 v9320 
                                                    let _v9319 = v9321 
                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                    let v9322 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v9323 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9318 v9322 
                                                    let _v9319 = v9323 
                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                    let v9324 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                    let v9325 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9318 v9324 
                                                    let _v9319 = v9325 
                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                    let v9326 : std_io_Error = v9318 
                                                    let _v9319 = v9326 
                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                    let v9327 : std_io_Error = v9318 
                                                    let _v9319 = v9327 
                                                    #endif
#else
                                                    let v9328 : std_io_Error = v9318 
                                                    let _v9319 = v9328 
                                                    #endif
                                                    let v9329 : std_io_Error = _v9319 
                                                    let v9332 : string = method19(v9185)
                                                    let v9333 : string option = method78(v9185)
                                                    let v9334 : (string -> US1) = method4()
                                                    let v9335 : US1 option = v9333 |> Option.map v9334 
                                                    let v9346 : US1 = US1_1
                                                    let v9347 : US1 = v9335 |> Option.defaultValue v9346 
                                                    match v9347 with
                                                    | US1_0(v9351) -> (* Some *)
                                                        let v9352 : bool = v9185 <> v9019 
                                                        if v9352 then
                                                            let v9355 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                            let v9356 : System.IO.DirectoryInfo = v9355 v9351
                                                            let v9357 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v9358 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9357 = v9358 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v9361 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9357 = v9361 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v9364 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9357 = v9364 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v9367 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9357 = v9367 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v9370 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9357 = v9370 
                                                            #endif
#else
                                                            let v9373 : System.IO.FileAttributes = v9356.Attributes
                                                            let _v9357 = v9373 
                                                            #endif
                                                            let v9374 : System.IO.FileAttributes = _v9357 
                                                            let v9379 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v9380 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9379 = v9380 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v9383 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9379 = v9383 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v9386 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9379 = v9386 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v9389 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9379 = v9389 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v9392 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                            let _v9379 = v9392 
                                                            #endif
#else
                                                            let v9395 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                            let _v9379 = v9395 
                                                            #endif
                                                            let v9396 : System.IO.FileAttributes = _v9379 
                                                            let v9401 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v9402 : bool = null |> unbox<bool>
                                                            let _v9401 = v9402 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v9405 : bool = null |> unbox<bool>
                                                            let _v9401 = v9405 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v9408 : bool = null |> unbox<bool>
                                                            let _v9401 = v9408 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v9411 : bool = null |> unbox<bool>
                                                            let _v9401 = v9411 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v9414 : bool = null |> unbox<bool>
                                                            let _v9401 = v9414 
                                                            #endif
#else
                                                            let v9417 : bool = v9374.HasFlag v9396 
                                                            let _v9401 = v9417 
                                                            #endif
                                                            let v9418 : bool = _v9401 
                                                            let v12520 : Result<std_path_PathBuf, std_io_Error> =
                                                                if v9418 then
                                                                    let v9423 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v9424 : file_info = null |> unbox<file_info>
                                                                    let _v9423 = v9424 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v9427 : file_info = null |> unbox<file_info>
                                                                    let _v9423 = v9427 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v9430 : file_info = null |> unbox<file_info>
                                                                    let _v9423 = v9430 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v9433 : file_info = null |> unbox<file_info>
                                                                    let _v9423 = v9433 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v9436 : file_info = null |> unbox<file_info>
                                                                    let _v9423 = v9436 
                                                                    #endif
#else
                                                                    let v9439 : (string -> file_info) = file_info 
                                                                    let v9440 : file_info = v9439 v9351
                                                                    let _v9423 = v9440 
                                                                    #endif
                                                                    let v9441 : file_info = _v9423 
                                                                    let v9446 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v9447 : string = null |> unbox<string>
                                                                    let _v9446 = v9447 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v9450 : string = null |> unbox<string>
                                                                    let _v9446 = v9450 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v9453 : string = null |> unbox<string>
                                                                    let _v9446 = v9453 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v9456 : string = null |> unbox<string>
                                                                    let _v9446 = v9456 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v9459 : string = null |> unbox<string>
                                                                    let _v9446 = v9459 
                                                                    #endif
#else
                                                                    let v9462 : string = v9441.LinkTarget
                                                                    let _v9446 = v9462 
                                                                    #endif
                                                                    let v9463 : string = _v9446 
                                                                    let v9468 : std_path_PathBuf = v9463 |> std_path_PathBuf 
                                                                    let v9471 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v9472 : string = "Ok($0)"
                                                                    let v9473 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9468 v9472 
                                                                    let _v9471 = v9473 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v9474 : string = "Ok($0)"
                                                                    let v9475 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9468 v9474 
                                                                    let _v9471 = v9475 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v9476 : string = "Ok($0)"
                                                                    let v9477 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9468 v9476 
                                                                    let _v9471 = v9477 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v9478 : Result<std_path_PathBuf, std_io_Error> = v9468 |> Ok
                                                                    let _v9471 = v9478 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v9479 : Result<std_path_PathBuf, std_io_Error> = v9468 |> Ok
                                                                    let _v9471 = v9479 
                                                                    #endif
#else
                                                                    let v9480 : Result<std_path_PathBuf, std_io_Error> = v9468 |> Ok
                                                                    let _v9471 = v9480 
                                                                    #endif
                                                                    let v9481 : Result<std_path_PathBuf, std_io_Error> = _v9471 
                                                                    v9481
                                                                else
                                                                    let v9484 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v9418} / path': {v9351} / n: {3uy}"
                                                                    let v9485 : unit = ()
                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                    let v9486 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v9487 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9484 v9486 
                                                                    let _v9485 = v9487 
                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                    let v9488 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v9489 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9484 v9488 
                                                                    let _v9485 = v9489 
                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                    let v9490 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                    let v9491 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9484 v9490 
                                                                    let _v9485 = v9491 
                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                    let v9492 : std_io_Error = v9484 
                                                                    let _v9485 = v9492 
                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                    let v9493 : std_io_Error = v9484 
                                                                    let _v9485 = v9493 
                                                                    #endif
#else
                                                                    let v9494 : std_io_Error = v9484 
                                                                    let _v9485 = v9494 
                                                                    #endif
                                                                    let v9495 : std_io_Error = _v9485 
                                                                    let v9498 : string = method19(v9351)
                                                                    let v9499 : string option = method78(v9351)
                                                                    let v9500 : (string -> US1) = method4()
                                                                    let v9501 : US1 option = v9499 |> Option.map v9500 
                                                                    let v9512 : US1 = US1_1
                                                                    let v9513 : US1 = v9501 |> Option.defaultValue v9512 
                                                                    match v9513 with
                                                                    | US1_0(v9517) -> (* Some *)
                                                                        let v9518 : bool = v9351 <> v9019 
                                                                        if v9518 then
                                                                            let v9521 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                            let v9522 : System.IO.DirectoryInfo = v9521 v9517
                                                                            let v9523 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v9524 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9523 = v9524 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v9527 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9523 = v9527 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v9530 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9523 = v9530 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v9533 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9523 = v9533 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v9536 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9523 = v9536 
                                                                            #endif
#else
                                                                            let v9539 : System.IO.FileAttributes = v9522.Attributes
                                                                            let _v9523 = v9539 
                                                                            #endif
                                                                            let v9540 : System.IO.FileAttributes = _v9523 
                                                                            let v9545 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v9546 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9545 = v9546 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v9549 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9545 = v9549 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v9552 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9545 = v9552 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v9555 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9545 = v9555 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v9558 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                            let _v9545 = v9558 
                                                                            #endif
#else
                                                                            let v9561 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                            let _v9545 = v9561 
                                                                            #endif
                                                                            let v9562 : System.IO.FileAttributes = _v9545 
                                                                            let v9567 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v9568 : bool = null |> unbox<bool>
                                                                            let _v9567 = v9568 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v9571 : bool = null |> unbox<bool>
                                                                            let _v9567 = v9571 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v9574 : bool = null |> unbox<bool>
                                                                            let _v9567 = v9574 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v9577 : bool = null |> unbox<bool>
                                                                            let _v9567 = v9577 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v9580 : bool = null |> unbox<bool>
                                                                            let _v9567 = v9580 
                                                                            #endif
#else
                                                                            let v9583 : bool = v9540.HasFlag v9562 
                                                                            let _v9567 = v9583 
                                                                            #endif
                                                                            let v9584 : bool = _v9567 
                                                                            let v12314 : Result<std_path_PathBuf, std_io_Error> =
                                                                                if v9584 then
                                                                                    let v9589 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v9590 : file_info = null |> unbox<file_info>
                                                                                    let _v9589 = v9590 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v9593 : file_info = null |> unbox<file_info>
                                                                                    let _v9589 = v9593 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v9596 : file_info = null |> unbox<file_info>
                                                                                    let _v9589 = v9596 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v9599 : file_info = null |> unbox<file_info>
                                                                                    let _v9589 = v9599 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v9602 : file_info = null |> unbox<file_info>
                                                                                    let _v9589 = v9602 
                                                                                    #endif
#else
                                                                                    let v9605 : (string -> file_info) = file_info 
                                                                                    let v9606 : file_info = v9605 v9517
                                                                                    let _v9589 = v9606 
                                                                                    #endif
                                                                                    let v9607 : file_info = _v9589 
                                                                                    let v9612 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v9613 : string = null |> unbox<string>
                                                                                    let _v9612 = v9613 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v9616 : string = null |> unbox<string>
                                                                                    let _v9612 = v9616 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v9619 : string = null |> unbox<string>
                                                                                    let _v9612 = v9619 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v9622 : string = null |> unbox<string>
                                                                                    let _v9612 = v9622 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v9625 : string = null |> unbox<string>
                                                                                    let _v9612 = v9625 
                                                                                    #endif
#else
                                                                                    let v9628 : string = v9607.LinkTarget
                                                                                    let _v9612 = v9628 
                                                                                    #endif
                                                                                    let v9629 : string = _v9612 
                                                                                    let v9634 : std_path_PathBuf = v9629 |> std_path_PathBuf 
                                                                                    let v9637 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v9638 : string = "Ok($0)"
                                                                                    let v9639 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9634 v9638 
                                                                                    let _v9637 = v9639 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v9640 : string = "Ok($0)"
                                                                                    let v9641 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9634 v9640 
                                                                                    let _v9637 = v9641 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v9642 : string = "Ok($0)"
                                                                                    let v9643 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9634 v9642 
                                                                                    let _v9637 = v9643 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v9644 : Result<std_path_PathBuf, std_io_Error> = v9634 |> Ok
                                                                                    let _v9637 = v9644 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v9645 : Result<std_path_PathBuf, std_io_Error> = v9634 |> Ok
                                                                                    let _v9637 = v9645 
                                                                                    #endif
#else
                                                                                    let v9646 : Result<std_path_PathBuf, std_io_Error> = v9634 |> Ok
                                                                                    let _v9637 = v9646 
                                                                                    #endif
                                                                                    let v9647 : Result<std_path_PathBuf, std_io_Error> = _v9637 
                                                                                    v9647
                                                                                else
                                                                                    let v9650 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v9584} / path': {v9517} / n: {4uy}"
                                                                                    let v9651 : unit = ()
                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                    let v9652 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v9653 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9650 v9652 
                                                                                    let _v9651 = v9653 
                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                    let v9654 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v9655 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9650 v9654 
                                                                                    let _v9651 = v9655 
                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                    let v9656 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                    let v9657 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9650 v9656 
                                                                                    let _v9651 = v9657 
                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                    let v9658 : std_io_Error = v9650 
                                                                                    let _v9651 = v9658 
                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                    let v9659 : std_io_Error = v9650 
                                                                                    let _v9651 = v9659 
                                                                                    #endif
#else
                                                                                    let v9660 : std_io_Error = v9650 
                                                                                    let _v9651 = v9660 
                                                                                    #endif
                                                                                    let v9661 : std_io_Error = _v9651 
                                                                                    let v9664 : string = method19(v9517)
                                                                                    let v9665 : string option = method78(v9517)
                                                                                    let v9666 : (string -> US1) = method4()
                                                                                    let v9667 : US1 option = v9665 |> Option.map v9666 
                                                                                    let v9678 : US1 = US1_1
                                                                                    let v9679 : US1 = v9667 |> Option.defaultValue v9678 
                                                                                    match v9679 with
                                                                                    | US1_0(v9683) -> (* Some *)
                                                                                        let v9684 : bool = v9517 <> v9019 
                                                                                        if v9684 then
                                                                                            let v9687 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                            let v9688 : System.IO.DirectoryInfo = v9687 v9683
                                                                                            let v9689 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v9690 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9689 = v9690 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v9693 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9689 = v9693 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v9696 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9689 = v9696 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v9699 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9689 = v9699 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v9702 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9689 = v9702 
                                                                                            #endif
#else
                                                                                            let v9705 : System.IO.FileAttributes = v9688.Attributes
                                                                                            let _v9689 = v9705 
                                                                                            #endif
                                                                                            let v9706 : System.IO.FileAttributes = _v9689 
                                                                                            let v9711 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v9712 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9711 = v9712 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v9715 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9711 = v9715 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v9718 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9711 = v9718 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v9721 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9711 = v9721 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v9724 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                            let _v9711 = v9724 
                                                                                            #endif
#else
                                                                                            let v9727 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                            let _v9711 = v9727 
                                                                                            #endif
                                                                                            let v9728 : System.IO.FileAttributes = _v9711 
                                                                                            let v9733 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v9734 : bool = null |> unbox<bool>
                                                                                            let _v9733 = v9734 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v9737 : bool = null |> unbox<bool>
                                                                                            let _v9733 = v9737 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v9740 : bool = null |> unbox<bool>
                                                                                            let _v9733 = v9740 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v9743 : bool = null |> unbox<bool>
                                                                                            let _v9733 = v9743 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v9746 : bool = null |> unbox<bool>
                                                                                            let _v9733 = v9746 
                                                                                            #endif
#else
                                                                                            let v9749 : bool = v9706.HasFlag v9728 
                                                                                            let _v9733 = v9749 
                                                                                            #endif
                                                                                            let v9750 : bool = _v9733 
                                                                                            let v12108 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                if v9750 then
                                                                                                    let v9755 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v9756 : file_info = null |> unbox<file_info>
                                                                                                    let _v9755 = v9756 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v9759 : file_info = null |> unbox<file_info>
                                                                                                    let _v9755 = v9759 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v9762 : file_info = null |> unbox<file_info>
                                                                                                    let _v9755 = v9762 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v9765 : file_info = null |> unbox<file_info>
                                                                                                    let _v9755 = v9765 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v9768 : file_info = null |> unbox<file_info>
                                                                                                    let _v9755 = v9768 
                                                                                                    #endif
#else
                                                                                                    let v9771 : (string -> file_info) = file_info 
                                                                                                    let v9772 : file_info = v9771 v9683
                                                                                                    let _v9755 = v9772 
                                                                                                    #endif
                                                                                                    let v9773 : file_info = _v9755 
                                                                                                    let v9778 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v9779 : string = null |> unbox<string>
                                                                                                    let _v9778 = v9779 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v9782 : string = null |> unbox<string>
                                                                                                    let _v9778 = v9782 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v9785 : string = null |> unbox<string>
                                                                                                    let _v9778 = v9785 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v9788 : string = null |> unbox<string>
                                                                                                    let _v9778 = v9788 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v9791 : string = null |> unbox<string>
                                                                                                    let _v9778 = v9791 
                                                                                                    #endif
#else
                                                                                                    let v9794 : string = v9773.LinkTarget
                                                                                                    let _v9778 = v9794 
                                                                                                    #endif
                                                                                                    let v9795 : string = _v9778 
                                                                                                    let v9800 : std_path_PathBuf = v9795 |> std_path_PathBuf 
                                                                                                    let v9803 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v9804 : string = "Ok($0)"
                                                                                                    let v9805 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9800 v9804 
                                                                                                    let _v9803 = v9805 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v9806 : string = "Ok($0)"
                                                                                                    let v9807 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9800 v9806 
                                                                                                    let _v9803 = v9807 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v9808 : string = "Ok($0)"
                                                                                                    let v9809 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9800 v9808 
                                                                                                    let _v9803 = v9809 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v9810 : Result<std_path_PathBuf, std_io_Error> = v9800 |> Ok
                                                                                                    let _v9803 = v9810 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v9811 : Result<std_path_PathBuf, std_io_Error> = v9800 |> Ok
                                                                                                    let _v9803 = v9811 
                                                                                                    #endif
#else
                                                                                                    let v9812 : Result<std_path_PathBuf, std_io_Error> = v9800 |> Ok
                                                                                                    let _v9803 = v9812 
                                                                                                    #endif
                                                                                                    let v9813 : Result<std_path_PathBuf, std_io_Error> = _v9803 
                                                                                                    v9813
                                                                                                else
                                                                                                    let v9816 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v9750} / path': {v9683} / n: {5uy}"
                                                                                                    let v9817 : unit = ()
                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                    let v9818 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v9819 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9816 v9818 
                                                                                                    let _v9817 = v9819 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                    let v9820 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v9821 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9816 v9820 
                                                                                                    let _v9817 = v9821 
                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                    let v9822 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                    let v9823 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9816 v9822 
                                                                                                    let _v9817 = v9823 
                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                    let v9824 : std_io_Error = v9816 
                                                                                                    let _v9817 = v9824 
                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                    let v9825 : std_io_Error = v9816 
                                                                                                    let _v9817 = v9825 
                                                                                                    #endif
#else
                                                                                                    let v9826 : std_io_Error = v9816 
                                                                                                    let _v9817 = v9826 
                                                                                                    #endif
                                                                                                    let v9827 : std_io_Error = _v9817 
                                                                                                    let v9830 : string = method19(v9683)
                                                                                                    let v9831 : string option = method78(v9683)
                                                                                                    let v9832 : (string -> US1) = method4()
                                                                                                    let v9833 : US1 option = v9831 |> Option.map v9832 
                                                                                                    let v9844 : US1 = US1_1
                                                                                                    let v9845 : US1 = v9833 |> Option.defaultValue v9844 
                                                                                                    match v9845 with
                                                                                                    | US1_0(v9849) -> (* Some *)
                                                                                                        let v9850 : bool = v9683 <> v9019 
                                                                                                        if v9850 then
                                                                                                            let v9853 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                            let v9854 : System.IO.DirectoryInfo = v9853 v9849
                                                                                                            let v9855 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v9856 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9855 = v9856 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v9859 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9855 = v9859 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v9862 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9855 = v9862 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v9865 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9855 = v9865 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v9868 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9855 = v9868 
                                                                                                            #endif
#else
                                                                                                            let v9871 : System.IO.FileAttributes = v9854.Attributes
                                                                                                            let _v9855 = v9871 
                                                                                                            #endif
                                                                                                            let v9872 : System.IO.FileAttributes = _v9855 
                                                                                                            let v9877 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v9878 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9877 = v9878 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v9881 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9877 = v9881 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v9884 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9877 = v9884 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v9887 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9877 = v9887 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v9890 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                            let _v9877 = v9890 
                                                                                                            #endif
#else
                                                                                                            let v9893 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                            let _v9877 = v9893 
                                                                                                            #endif
                                                                                                            let v9894 : System.IO.FileAttributes = _v9877 
                                                                                                            let v9899 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v9900 : bool = null |> unbox<bool>
                                                                                                            let _v9899 = v9900 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v9903 : bool = null |> unbox<bool>
                                                                                                            let _v9899 = v9903 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v9906 : bool = null |> unbox<bool>
                                                                                                            let _v9899 = v9906 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v9909 : bool = null |> unbox<bool>
                                                                                                            let _v9899 = v9909 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v9912 : bool = null |> unbox<bool>
                                                                                                            let _v9899 = v9912 
                                                                                                            #endif
#else
                                                                                                            let v9915 : bool = v9872.HasFlag v9894 
                                                                                                            let _v9899 = v9915 
                                                                                                            #endif
                                                                                                            let v9916 : bool = _v9899 
                                                                                                            let v11902 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                if v9916 then
                                                                                                                    let v9921 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v9922 : file_info = null |> unbox<file_info>
                                                                                                                    let _v9921 = v9922 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v9925 : file_info = null |> unbox<file_info>
                                                                                                                    let _v9921 = v9925 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v9928 : file_info = null |> unbox<file_info>
                                                                                                                    let _v9921 = v9928 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v9931 : file_info = null |> unbox<file_info>
                                                                                                                    let _v9921 = v9931 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v9934 : file_info = null |> unbox<file_info>
                                                                                                                    let _v9921 = v9934 
                                                                                                                    #endif
#else
                                                                                                                    let v9937 : (string -> file_info) = file_info 
                                                                                                                    let v9938 : file_info = v9937 v9849
                                                                                                                    let _v9921 = v9938 
                                                                                                                    #endif
                                                                                                                    let v9939 : file_info = _v9921 
                                                                                                                    let v9944 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v9945 : string = null |> unbox<string>
                                                                                                                    let _v9944 = v9945 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v9948 : string = null |> unbox<string>
                                                                                                                    let _v9944 = v9948 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v9951 : string = null |> unbox<string>
                                                                                                                    let _v9944 = v9951 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v9954 : string = null |> unbox<string>
                                                                                                                    let _v9944 = v9954 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v9957 : string = null |> unbox<string>
                                                                                                                    let _v9944 = v9957 
                                                                                                                    #endif
#else
                                                                                                                    let v9960 : string = v9939.LinkTarget
                                                                                                                    let _v9944 = v9960 
                                                                                                                    #endif
                                                                                                                    let v9961 : string = _v9944 
                                                                                                                    let v9966 : std_path_PathBuf = v9961 |> std_path_PathBuf 
                                                                                                                    let v9969 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v9970 : string = "Ok($0)"
                                                                                                                    let v9971 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9966 v9970 
                                                                                                                    let _v9969 = v9971 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v9972 : string = "Ok($0)"
                                                                                                                    let v9973 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9966 v9972 
                                                                                                                    let _v9969 = v9973 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v9974 : string = "Ok($0)"
                                                                                                                    let v9975 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v9966 v9974 
                                                                                                                    let _v9969 = v9975 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v9976 : Result<std_path_PathBuf, std_io_Error> = v9966 |> Ok
                                                                                                                    let _v9969 = v9976 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v9977 : Result<std_path_PathBuf, std_io_Error> = v9966 |> Ok
                                                                                                                    let _v9969 = v9977 
                                                                                                                    #endif
#else
                                                                                                                    let v9978 : Result<std_path_PathBuf, std_io_Error> = v9966 |> Ok
                                                                                                                    let _v9969 = v9978 
                                                                                                                    #endif
                                                                                                                    let v9979 : Result<std_path_PathBuf, std_io_Error> = _v9969 
                                                                                                                    v9979
                                                                                                                else
                                                                                                                    let v9982 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v9916} / path': {v9849} / n: {6uy}"
                                                                                                                    let v9983 : unit = ()
                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                    let v9984 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v9985 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9982 v9984 
                                                                                                                    let _v9983 = v9985 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                    let v9986 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v9987 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9982 v9986 
                                                                                                                    let _v9983 = v9987 
                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                    let v9988 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                    let v9989 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v9982 v9988 
                                                                                                                    let _v9983 = v9989 
                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                    let v9990 : std_io_Error = v9982 
                                                                                                                    let _v9983 = v9990 
                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                    let v9991 : std_io_Error = v9982 
                                                                                                                    let _v9983 = v9991 
                                                                                                                    #endif
#else
                                                                                                                    let v9992 : std_io_Error = v9982 
                                                                                                                    let _v9983 = v9992 
                                                                                                                    #endif
                                                                                                                    let v9993 : std_io_Error = _v9983 
                                                                                                                    let v9996 : string = method19(v9849)
                                                                                                                    let v9997 : string option = method78(v9849)
                                                                                                                    let v9998 : (string -> US1) = method4()
                                                                                                                    let v9999 : US1 option = v9997 |> Option.map v9998 
                                                                                                                    let v10010 : US1 = US1_1
                                                                                                                    let v10011 : US1 = v9999 |> Option.defaultValue v10010 
                                                                                                                    match v10011 with
                                                                                                                    | US1_0(v10015) -> (* Some *)
                                                                                                                        let v10016 : bool = v9849 <> v9019 
                                                                                                                        if v10016 then
                                                                                                                            let v10019 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                            let v10020 : System.IO.DirectoryInfo = v10019 v10015
                                                                                                                            let v10021 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v10022 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10021 = v10022 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v10025 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10021 = v10025 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v10028 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10021 = v10028 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v10031 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10021 = v10031 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v10034 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10021 = v10034 
                                                                                                                            #endif
#else
                                                                                                                            let v10037 : System.IO.FileAttributes = v10020.Attributes
                                                                                                                            let _v10021 = v10037 
                                                                                                                            #endif
                                                                                                                            let v10038 : System.IO.FileAttributes = _v10021 
                                                                                                                            let v10043 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v10044 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10043 = v10044 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v10047 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10043 = v10047 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v10050 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10043 = v10050 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v10053 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10043 = v10053 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v10056 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                            let _v10043 = v10056 
                                                                                                                            #endif
#else
                                                                                                                            let v10059 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                            let _v10043 = v10059 
                                                                                                                            #endif
                                                                                                                            let v10060 : System.IO.FileAttributes = _v10043 
                                                                                                                            let v10065 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v10066 : bool = null |> unbox<bool>
                                                                                                                            let _v10065 = v10066 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v10069 : bool = null |> unbox<bool>
                                                                                                                            let _v10065 = v10069 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v10072 : bool = null |> unbox<bool>
                                                                                                                            let _v10065 = v10072 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v10075 : bool = null |> unbox<bool>
                                                                                                                            let _v10065 = v10075 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v10078 : bool = null |> unbox<bool>
                                                                                                                            let _v10065 = v10078 
                                                                                                                            #endif
#else
                                                                                                                            let v10081 : bool = v10038.HasFlag v10060 
                                                                                                                            let _v10065 = v10081 
                                                                                                                            #endif
                                                                                                                            let v10082 : bool = _v10065 
                                                                                                                            let v11696 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                if v10082 then
                                                                                                                                    let v10087 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v10088 : file_info = null |> unbox<file_info>
                                                                                                                                    let _v10087 = v10088 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v10091 : file_info = null |> unbox<file_info>
                                                                                                                                    let _v10087 = v10091 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v10094 : file_info = null |> unbox<file_info>
                                                                                                                                    let _v10087 = v10094 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v10097 : file_info = null |> unbox<file_info>
                                                                                                                                    let _v10087 = v10097 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v10100 : file_info = null |> unbox<file_info>
                                                                                                                                    let _v10087 = v10100 
                                                                                                                                    #endif
#else
                                                                                                                                    let v10103 : (string -> file_info) = file_info 
                                                                                                                                    let v10104 : file_info = v10103 v10015
                                                                                                                                    let _v10087 = v10104 
                                                                                                                                    #endif
                                                                                                                                    let v10105 : file_info = _v10087 
                                                                                                                                    let v10110 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v10111 : string = null |> unbox<string>
                                                                                                                                    let _v10110 = v10111 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v10114 : string = null |> unbox<string>
                                                                                                                                    let _v10110 = v10114 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v10117 : string = null |> unbox<string>
                                                                                                                                    let _v10110 = v10117 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v10120 : string = null |> unbox<string>
                                                                                                                                    let _v10110 = v10120 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v10123 : string = null |> unbox<string>
                                                                                                                                    let _v10110 = v10123 
                                                                                                                                    #endif
#else
                                                                                                                                    let v10126 : string = v10105.LinkTarget
                                                                                                                                    let _v10110 = v10126 
                                                                                                                                    #endif
                                                                                                                                    let v10127 : string = _v10110 
                                                                                                                                    let v10132 : std_path_PathBuf = v10127 |> std_path_PathBuf 
                                                                                                                                    let v10135 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v10136 : string = "Ok($0)"
                                                                                                                                    let v10137 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10132 v10136 
                                                                                                                                    let _v10135 = v10137 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v10138 : string = "Ok($0)"
                                                                                                                                    let v10139 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10132 v10138 
                                                                                                                                    let _v10135 = v10139 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v10140 : string = "Ok($0)"
                                                                                                                                    let v10141 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10132 v10140 
                                                                                                                                    let _v10135 = v10141 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v10142 : Result<std_path_PathBuf, std_io_Error> = v10132 |> Ok
                                                                                                                                    let _v10135 = v10142 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v10143 : Result<std_path_PathBuf, std_io_Error> = v10132 |> Ok
                                                                                                                                    let _v10135 = v10143 
                                                                                                                                    #endif
#else
                                                                                                                                    let v10144 : Result<std_path_PathBuf, std_io_Error> = v10132 |> Ok
                                                                                                                                    let _v10135 = v10144 
                                                                                                                                    #endif
                                                                                                                                    let v10145 : Result<std_path_PathBuf, std_io_Error> = _v10135 
                                                                                                                                    v10145
                                                                                                                                else
                                                                                                                                    let v10148 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v10082} / path': {v10015} / n: {7uy}"
                                                                                                                                    let v10149 : unit = ()
                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                    let v10150 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v10151 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10148 v10150 
                                                                                                                                    let _v10149 = v10151 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                    let v10152 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v10153 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10148 v10152 
                                                                                                                                    let _v10149 = v10153 
                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                    let v10154 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                    let v10155 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10148 v10154 
                                                                                                                                    let _v10149 = v10155 
                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                    let v10156 : std_io_Error = v10148 
                                                                                                                                    let _v10149 = v10156 
                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                    let v10157 : std_io_Error = v10148 
                                                                                                                                    let _v10149 = v10157 
                                                                                                                                    #endif
#else
                                                                                                                                    let v10158 : std_io_Error = v10148 
                                                                                                                                    let _v10149 = v10158 
                                                                                                                                    #endif
                                                                                                                                    let v10159 : std_io_Error = _v10149 
                                                                                                                                    let v10162 : string = method19(v10015)
                                                                                                                                    let v10163 : string option = method78(v10015)
                                                                                                                                    let v10164 : (string -> US1) = method4()
                                                                                                                                    let v10165 : US1 option = v10163 |> Option.map v10164 
                                                                                                                                    let v10176 : US1 = US1_1
                                                                                                                                    let v10177 : US1 = v10165 |> Option.defaultValue v10176 
                                                                                                                                    match v10177 with
                                                                                                                                    | US1_0(v10181) -> (* Some *)
                                                                                                                                        let v10182 : bool = v10015 <> v9019 
                                                                                                                                        if v10182 then
                                                                                                                                            let v10185 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                                            let v10186 : System.IO.DirectoryInfo = v10185 v10181
                                                                                                                                            let v10187 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v10188 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10187 = v10188 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v10191 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10187 = v10191 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v10194 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10187 = v10194 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v10197 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10187 = v10197 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v10200 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10187 = v10200 
                                                                                                                                            #endif
#else
                                                                                                                                            let v10203 : System.IO.FileAttributes = v10186.Attributes
                                                                                                                                            let _v10187 = v10203 
                                                                                                                                            #endif
                                                                                                                                            let v10204 : System.IO.FileAttributes = _v10187 
                                                                                                                                            let v10209 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v10210 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10209 = v10210 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v10213 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10209 = v10213 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v10216 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10209 = v10216 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v10219 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10209 = v10219 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v10222 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                            let _v10209 = v10222 
                                                                                                                                            #endif
#else
                                                                                                                                            let v10225 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                                            let _v10209 = v10225 
                                                                                                                                            #endif
                                                                                                                                            let v10226 : System.IO.FileAttributes = _v10209 
                                                                                                                                            let v10231 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v10232 : bool = null |> unbox<bool>
                                                                                                                                            let _v10231 = v10232 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v10235 : bool = null |> unbox<bool>
                                                                                                                                            let _v10231 = v10235 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v10238 : bool = null |> unbox<bool>
                                                                                                                                            let _v10231 = v10238 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v10241 : bool = null |> unbox<bool>
                                                                                                                                            let _v10231 = v10241 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v10244 : bool = null |> unbox<bool>
                                                                                                                                            let _v10231 = v10244 
                                                                                                                                            #endif
#else
                                                                                                                                            let v10247 : bool = v10204.HasFlag v10226 
                                                                                                                                            let _v10231 = v10247 
                                                                                                                                            #endif
                                                                                                                                            let v10248 : bool = _v10231 
                                                                                                                                            let v11490 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                if v10248 then
                                                                                                                                                    let v10253 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v10254 : file_info = null |> unbox<file_info>
                                                                                                                                                    let _v10253 = v10254 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v10257 : file_info = null |> unbox<file_info>
                                                                                                                                                    let _v10253 = v10257 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v10260 : file_info = null |> unbox<file_info>
                                                                                                                                                    let _v10253 = v10260 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v10263 : file_info = null |> unbox<file_info>
                                                                                                                                                    let _v10253 = v10263 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v10266 : file_info = null |> unbox<file_info>
                                                                                                                                                    let _v10253 = v10266 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v10269 : (string -> file_info) = file_info 
                                                                                                                                                    let v10270 : file_info = v10269 v10181
                                                                                                                                                    let _v10253 = v10270 
                                                                                                                                                    #endif
                                                                                                                                                    let v10271 : file_info = _v10253 
                                                                                                                                                    let v10276 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v10277 : string = null |> unbox<string>
                                                                                                                                                    let _v10276 = v10277 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v10280 : string = null |> unbox<string>
                                                                                                                                                    let _v10276 = v10280 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v10283 : string = null |> unbox<string>
                                                                                                                                                    let _v10276 = v10283 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v10286 : string = null |> unbox<string>
                                                                                                                                                    let _v10276 = v10286 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v10289 : string = null |> unbox<string>
                                                                                                                                                    let _v10276 = v10289 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v10292 : string = v10271.LinkTarget
                                                                                                                                                    let _v10276 = v10292 
                                                                                                                                                    #endif
                                                                                                                                                    let v10293 : string = _v10276 
                                                                                                                                                    let v10298 : std_path_PathBuf = v10293 |> std_path_PathBuf 
                                                                                                                                                    let v10301 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v10302 : string = "Ok($0)"
                                                                                                                                                    let v10303 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10298 v10302 
                                                                                                                                                    let _v10301 = v10303 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v10304 : string = "Ok($0)"
                                                                                                                                                    let v10305 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10298 v10304 
                                                                                                                                                    let _v10301 = v10305 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v10306 : string = "Ok($0)"
                                                                                                                                                    let v10307 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10298 v10306 
                                                                                                                                                    let _v10301 = v10307 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v10308 : Result<std_path_PathBuf, std_io_Error> = v10298 |> Ok
                                                                                                                                                    let _v10301 = v10308 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v10309 : Result<std_path_PathBuf, std_io_Error> = v10298 |> Ok
                                                                                                                                                    let _v10301 = v10309 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v10310 : Result<std_path_PathBuf, std_io_Error> = v10298 |> Ok
                                                                                                                                                    let _v10301 = v10310 
                                                                                                                                                    #endif
                                                                                                                                                    let v10311 : Result<std_path_PathBuf, std_io_Error> = _v10301 
                                                                                                                                                    v10311
                                                                                                                                                else
                                                                                                                                                    let v10314 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v10248} / path': {v10181} / n: {8uy}"
                                                                                                                                                    let v10315 : unit = ()
                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                    let v10316 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v10317 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10314 v10316 
                                                                                                                                                    let _v10315 = v10317 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                    let v10318 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v10319 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10314 v10318 
                                                                                                                                                    let _v10315 = v10319 
                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                    let v10320 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                    let v10321 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10314 v10320 
                                                                                                                                                    let _v10315 = v10321 
                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                    let v10322 : std_io_Error = v10314 
                                                                                                                                                    let _v10315 = v10322 
                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                    let v10323 : std_io_Error = v10314 
                                                                                                                                                    let _v10315 = v10323 
                                                                                                                                                    #endif
#else
                                                                                                                                                    let v10324 : std_io_Error = v10314 
                                                                                                                                                    let _v10315 = v10324 
                                                                                                                                                    #endif
                                                                                                                                                    let v10325 : std_io_Error = _v10315 
                                                                                                                                                    let v10328 : string = method19(v10181)
                                                                                                                                                    let v10329 : string option = method78(v10181)
                                                                                                                                                    let v10330 : (string -> US1) = method4()
                                                                                                                                                    let v10331 : US1 option = v10329 |> Option.map v10330 
                                                                                                                                                    let v10342 : US1 = US1_1
                                                                                                                                                    let v10343 : US1 = v10331 |> Option.defaultValue v10342 
                                                                                                                                                    match v10343 with
                                                                                                                                                    | US1_0(v10347) -> (* Some *)
                                                                                                                                                        let v10348 : bool = v10181 <> v9019 
                                                                                                                                                        if v10348 then
                                                                                                                                                            let v10351 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                                                            let v10352 : System.IO.DirectoryInfo = v10351 v10347
                                                                                                                                                            let v10353 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v10354 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10353 = v10354 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v10357 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10353 = v10357 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v10360 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10353 = v10360 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v10363 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10353 = v10363 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v10366 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10353 = v10366 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v10369 : System.IO.FileAttributes = v10352.Attributes
                                                                                                                                                            let _v10353 = v10369 
                                                                                                                                                            #endif
                                                                                                                                                            let v10370 : System.IO.FileAttributes = _v10353 
                                                                                                                                                            let v10375 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v10376 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10375 = v10376 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v10379 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10375 = v10379 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v10382 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10375 = v10382 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v10385 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10375 = v10385 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v10388 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                            let _v10375 = v10388 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v10391 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                                                            let _v10375 = v10391 
                                                                                                                                                            #endif
                                                                                                                                                            let v10392 : System.IO.FileAttributes = _v10375 
                                                                                                                                                            let v10397 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v10398 : bool = null |> unbox<bool>
                                                                                                                                                            let _v10397 = v10398 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v10401 : bool = null |> unbox<bool>
                                                                                                                                                            let _v10397 = v10401 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v10404 : bool = null |> unbox<bool>
                                                                                                                                                            let _v10397 = v10404 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v10407 : bool = null |> unbox<bool>
                                                                                                                                                            let _v10397 = v10407 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v10410 : bool = null |> unbox<bool>
                                                                                                                                                            let _v10397 = v10410 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v10413 : bool = v10370.HasFlag v10392 
                                                                                                                                                            let _v10397 = v10413 
                                                                                                                                                            #endif
                                                                                                                                                            let v10414 : bool = _v10397 
                                                                                                                                                            let v11284 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                if v10414 then
                                                                                                                                                                    let v10419 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v10420 : file_info = null |> unbox<file_info>
                                                                                                                                                                    let _v10419 = v10420 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v10423 : file_info = null |> unbox<file_info>
                                                                                                                                                                    let _v10419 = v10423 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v10426 : file_info = null |> unbox<file_info>
                                                                                                                                                                    let _v10419 = v10426 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v10429 : file_info = null |> unbox<file_info>
                                                                                                                                                                    let _v10419 = v10429 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v10432 : file_info = null |> unbox<file_info>
                                                                                                                                                                    let _v10419 = v10432 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v10435 : (string -> file_info) = file_info 
                                                                                                                                                                    let v10436 : file_info = v10435 v10347
                                                                                                                                                                    let _v10419 = v10436 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v10437 : file_info = _v10419 
                                                                                                                                                                    let v10442 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v10443 : string = null |> unbox<string>
                                                                                                                                                                    let _v10442 = v10443 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v10446 : string = null |> unbox<string>
                                                                                                                                                                    let _v10442 = v10446 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v10449 : string = null |> unbox<string>
                                                                                                                                                                    let _v10442 = v10449 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v10452 : string = null |> unbox<string>
                                                                                                                                                                    let _v10442 = v10452 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v10455 : string = null |> unbox<string>
                                                                                                                                                                    let _v10442 = v10455 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v10458 : string = v10437.LinkTarget
                                                                                                                                                                    let _v10442 = v10458 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v10459 : string = _v10442 
                                                                                                                                                                    let v10464 : std_path_PathBuf = v10459 |> std_path_PathBuf 
                                                                                                                                                                    let v10467 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v10468 : string = "Ok($0)"
                                                                                                                                                                    let v10469 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10464 v10468 
                                                                                                                                                                    let _v10467 = v10469 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v10470 : string = "Ok($0)"
                                                                                                                                                                    let v10471 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10464 v10470 
                                                                                                                                                                    let _v10467 = v10471 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v10472 : string = "Ok($0)"
                                                                                                                                                                    let v10473 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10464 v10472 
                                                                                                                                                                    let _v10467 = v10473 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v10474 : Result<std_path_PathBuf, std_io_Error> = v10464 |> Ok
                                                                                                                                                                    let _v10467 = v10474 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v10475 : Result<std_path_PathBuf, std_io_Error> = v10464 |> Ok
                                                                                                                                                                    let _v10467 = v10475 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v10476 : Result<std_path_PathBuf, std_io_Error> = v10464 |> Ok
                                                                                                                                                                    let _v10467 = v10476 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v10477 : Result<std_path_PathBuf, std_io_Error> = _v10467 
                                                                                                                                                                    v10477
                                                                                                                                                                else
                                                                                                                                                                    let v10480 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v10414} / path': {v10347} / n: {9uy}"
                                                                                                                                                                    let v10481 : unit = ()
                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                    let v10482 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v10483 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10480 v10482 
                                                                                                                                                                    let _v10481 = v10483 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                    let v10484 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v10485 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10480 v10484 
                                                                                                                                                                    let _v10481 = v10485 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                    let v10486 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                    let v10487 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10480 v10486 
                                                                                                                                                                    let _v10481 = v10487 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                    let v10488 : std_io_Error = v10480 
                                                                                                                                                                    let _v10481 = v10488 
                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                    let v10489 : std_io_Error = v10480 
                                                                                                                                                                    let _v10481 = v10489 
                                                                                                                                                                    #endif
#else
                                                                                                                                                                    let v10490 : std_io_Error = v10480 
                                                                                                                                                                    let _v10481 = v10490 
                                                                                                                                                                    #endif
                                                                                                                                                                    let v10491 : std_io_Error = _v10481 
                                                                                                                                                                    let v10494 : string = method19(v10347)
                                                                                                                                                                    let v10495 : string option = method78(v10347)
                                                                                                                                                                    let v10496 : (string -> US1) = method4()
                                                                                                                                                                    let v10497 : US1 option = v10495 |> Option.map v10496 
                                                                                                                                                                    let v10508 : US1 = US1_1
                                                                                                                                                                    let v10509 : US1 = v10497 |> Option.defaultValue v10508 
                                                                                                                                                                    match v10509 with
                                                                                                                                                                    | US1_0(v10513) -> (* Some *)
                                                                                                                                                                        let v10514 : bool = v10347 <> v9019 
                                                                                                                                                                        if v10514 then
                                                                                                                                                                            let v10517 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                                                                            let v10518 : System.IO.DirectoryInfo = v10517 v10513
                                                                                                                                                                            let v10519 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v10520 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10519 = v10520 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v10523 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10519 = v10523 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v10526 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10519 = v10526 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v10529 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10519 = v10529 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v10532 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10519 = v10532 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v10535 : System.IO.FileAttributes = v10518.Attributes
                                                                                                                                                                            let _v10519 = v10535 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v10536 : System.IO.FileAttributes = _v10519 
                                                                                                                                                                            let v10541 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v10542 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10541 = v10542 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v10545 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10541 = v10545 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v10548 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10541 = v10548 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v10551 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10541 = v10551 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v10554 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                            let _v10541 = v10554 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v10557 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                                                                            let _v10541 = v10557 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v10558 : System.IO.FileAttributes = _v10541 
                                                                                                                                                                            let v10563 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v10564 : bool = null |> unbox<bool>
                                                                                                                                                                            let _v10563 = v10564 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v10567 : bool = null |> unbox<bool>
                                                                                                                                                                            let _v10563 = v10567 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v10570 : bool = null |> unbox<bool>
                                                                                                                                                                            let _v10563 = v10570 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v10573 : bool = null |> unbox<bool>
                                                                                                                                                                            let _v10563 = v10573 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v10576 : bool = null |> unbox<bool>
                                                                                                                                                                            let _v10563 = v10576 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v10579 : bool = v10536.HasFlag v10558 
                                                                                                                                                                            let _v10563 = v10579 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v10580 : bool = _v10563 
                                                                                                                                                                            let v11078 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                if v10580 then
                                                                                                                                                                                    let v10585 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v10586 : file_info = null |> unbox<file_info>
                                                                                                                                                                                    let _v10585 = v10586 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v10589 : file_info = null |> unbox<file_info>
                                                                                                                                                                                    let _v10585 = v10589 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v10592 : file_info = null |> unbox<file_info>
                                                                                                                                                                                    let _v10585 = v10592 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v10595 : file_info = null |> unbox<file_info>
                                                                                                                                                                                    let _v10585 = v10595 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v10598 : file_info = null |> unbox<file_info>
                                                                                                                                                                                    let _v10585 = v10598 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v10601 : (string -> file_info) = file_info 
                                                                                                                                                                                    let v10602 : file_info = v10601 v10513
                                                                                                                                                                                    let _v10585 = v10602 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v10603 : file_info = _v10585 
                                                                                                                                                                                    let v10608 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v10609 : string = null |> unbox<string>
                                                                                                                                                                                    let _v10608 = v10609 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v10612 : string = null |> unbox<string>
                                                                                                                                                                                    let _v10608 = v10612 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v10615 : string = null |> unbox<string>
                                                                                                                                                                                    let _v10608 = v10615 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v10618 : string = null |> unbox<string>
                                                                                                                                                                                    let _v10608 = v10618 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v10621 : string = null |> unbox<string>
                                                                                                                                                                                    let _v10608 = v10621 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v10624 : string = v10603.LinkTarget
                                                                                                                                                                                    let _v10608 = v10624 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v10625 : string = _v10608 
                                                                                                                                                                                    let v10630 : std_path_PathBuf = v10625 |> std_path_PathBuf 
                                                                                                                                                                                    let v10633 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v10634 : string = "Ok($0)"
                                                                                                                                                                                    let v10635 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10630 v10634 
                                                                                                                                                                                    let _v10633 = v10635 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v10636 : string = "Ok($0)"
                                                                                                                                                                                    let v10637 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10630 v10636 
                                                                                                                                                                                    let _v10633 = v10637 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v10638 : string = "Ok($0)"
                                                                                                                                                                                    let v10639 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10630 v10638 
                                                                                                                                                                                    let _v10633 = v10639 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v10640 : Result<std_path_PathBuf, std_io_Error> = v10630 |> Ok
                                                                                                                                                                                    let _v10633 = v10640 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v10641 : Result<std_path_PathBuf, std_io_Error> = v10630 |> Ok
                                                                                                                                                                                    let _v10633 = v10641 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v10642 : Result<std_path_PathBuf, std_io_Error> = v10630 |> Ok
                                                                                                                                                                                    let _v10633 = v10642 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v10643 : Result<std_path_PathBuf, std_io_Error> = _v10633 
                                                                                                                                                                                    v10643
                                                                                                                                                                                else
                                                                                                                                                                                    let v10646 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v10580} / path': {v10513} / n: {10uy}"
                                                                                                                                                                                    let v10647 : unit = ()
                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                    let v10648 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v10649 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10646 v10648 
                                                                                                                                                                                    let _v10647 = v10649 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                    let v10650 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v10651 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10646 v10650 
                                                                                                                                                                                    let _v10647 = v10651 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                    let v10652 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                    let v10653 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10646 v10652 
                                                                                                                                                                                    let _v10647 = v10653 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                    let v10654 : std_io_Error = v10646 
                                                                                                                                                                                    let _v10647 = v10654 
                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                    let v10655 : std_io_Error = v10646 
                                                                                                                                                                                    let _v10647 = v10655 
                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                    let v10656 : std_io_Error = v10646 
                                                                                                                                                                                    let _v10647 = v10656 
                                                                                                                                                                                    #endif
                                                                                                                                                                                    let v10657 : std_io_Error = _v10647 
                                                                                                                                                                                    let v10660 : string = method19(v10513)
                                                                                                                                                                                    let v10661 : string option = method78(v10513)
                                                                                                                                                                                    let v10662 : (string -> US1) = method4()
                                                                                                                                                                                    let v10663 : US1 option = v10661 |> Option.map v10662 
                                                                                                                                                                                    let v10674 : US1 = US1_1
                                                                                                                                                                                    let v10675 : US1 = v10663 |> Option.defaultValue v10674 
                                                                                                                                                                                    match v10675 with
                                                                                                                                                                                    | US1_0(v10679) -> (* Some *)
                                                                                                                                                                                        let v10680 : bool = v10513 <> v9019 
                                                                                                                                                                                        if v10680 then
                                                                                                                                                                                            let v10683 : (string -> System.IO.DirectoryInfo) = System.IO.DirectoryInfo 
                                                                                                                                                                                            let v10684 : System.IO.DirectoryInfo = v10683 v10679
                                                                                                                                                                                            let v10685 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10686 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10685 = v10686 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10689 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10685 = v10689 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10692 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10685 = v10692 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10695 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10685 = v10695 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10698 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10685 = v10698 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10701 : System.IO.FileAttributes = v10684.Attributes
                                                                                                                                                                                            let _v10685 = v10701 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10702 : System.IO.FileAttributes = _v10685 
                                                                                                                                                                                            let v10707 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10708 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10707 = v10708 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10711 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10707 = v10711 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10714 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10707 = v10714 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10717 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10707 = v10717 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10720 : System.IO.FileAttributes = null |> unbox<System.IO.FileAttributes>
                                                                                                                                                                                            let _v10707 = v10720 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10723 : System.IO.FileAttributes = System.IO.FileAttributes.ReparsePoint
                                                                                                                                                                                            let _v10707 = v10723 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10724 : System.IO.FileAttributes = _v10707 
                                                                                                                                                                                            let v10729 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10730 : bool = null |> unbox<bool>
                                                                                                                                                                                            let _v10729 = v10730 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10733 : bool = null |> unbox<bool>
                                                                                                                                                                                            let _v10729 = v10733 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10736 : bool = null |> unbox<bool>
                                                                                                                                                                                            let _v10729 = v10736 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10739 : bool = null |> unbox<bool>
                                                                                                                                                                                            let _v10729 = v10739 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10742 : bool = null |> unbox<bool>
                                                                                                                                                                                            let _v10729 = v10742 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10745 : bool = v10702.HasFlag v10724 
                                                                                                                                                                                            let _v10729 = v10745 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10746 : bool = _v10729 
                                                                                                                                                                                            let v10872 : Result<std_path_PathBuf, std_io_Error> =
                                                                                                                                                                                                if v10746 then
                                                                                                                                                                                                    let v10751 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v10752 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                    let _v10751 = v10752 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v10755 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                    let _v10751 = v10755 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v10758 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                    let _v10751 = v10758 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v10761 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                    let _v10751 = v10761 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v10764 : file_info = null |> unbox<file_info>
                                                                                                                                                                                                    let _v10751 = v10764 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v10767 : (string -> file_info) = file_info 
                                                                                                                                                                                                    let v10768 : file_info = v10767 v10679
                                                                                                                                                                                                    let _v10751 = v10768 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v10769 : file_info = _v10751 
                                                                                                                                                                                                    let v10774 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v10775 : string = null |> unbox<string>
                                                                                                                                                                                                    let _v10774 = v10775 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v10778 : string = null |> unbox<string>
                                                                                                                                                                                                    let _v10774 = v10778 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v10781 : string = null |> unbox<string>
                                                                                                                                                                                                    let _v10774 = v10781 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v10784 : string = null |> unbox<string>
                                                                                                                                                                                                    let _v10774 = v10784 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v10787 : string = null |> unbox<string>
                                                                                                                                                                                                    let _v10774 = v10787 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v10790 : string = v10769.LinkTarget
                                                                                                                                                                                                    let _v10774 = v10790 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v10791 : string = _v10774 
                                                                                                                                                                                                    let v10796 : std_path_PathBuf = v10791 |> std_path_PathBuf 
                                                                                                                                                                                                    let v10799 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v10800 : string = "Ok($0)"
                                                                                                                                                                                                    let v10801 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10796 v10800 
                                                                                                                                                                                                    let _v10799 = v10801 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v10802 : string = "Ok($0)"
                                                                                                                                                                                                    let v10803 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10796 v10802 
                                                                                                                                                                                                    let _v10799 = v10803 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v10804 : string = "Ok($0)"
                                                                                                                                                                                                    let v10805 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10796 v10804 
                                                                                                                                                                                                    let _v10799 = v10805 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v10806 : Result<std_path_PathBuf, std_io_Error> = v10796 |> Ok
                                                                                                                                                                                                    let _v10799 = v10806 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v10807 : Result<std_path_PathBuf, std_io_Error> = v10796 |> Ok
                                                                                                                                                                                                    let _v10799 = v10807 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v10808 : Result<std_path_PathBuf, std_io_Error> = v10796 |> Ok
                                                                                                                                                                                                    let _v10799 = v10808 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v10809 : Result<std_path_PathBuf, std_io_Error> = _v10799 
                                                                                                                                                                                                    v10809
                                                                                                                                                                                                else
                                                                                                                                                                                                    let v10812 : string = $"file_system.read_link / Fsharp / The file or directory is not a reparse point. / path: {v1} / result: {v10746} / path': {v10679} / n: {11uy}"
                                                                                                                                                                                                    let v10813 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v10814 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v10815 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10812 v10814 
                                                                                                                                                                                                    let _v10813 = v10815 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v10816 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v10817 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10812 v10816 
                                                                                                                                                                                                    let _v10813 = v10817 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v10818 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v10819 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10812 v10818 
                                                                                                                                                                                                    let _v10813 = v10819 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v10820 : std_io_Error = v10812 
                                                                                                                                                                                                    let _v10813 = v10820 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v10821 : std_io_Error = v10812 
                                                                                                                                                                                                    let _v10813 = v10821 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v10822 : std_io_Error = v10812 
                                                                                                                                                                                                    let _v10813 = v10822 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v10823 : std_io_Error = _v10813 
                                                                                                                                                                                                    let v10826 : string = method19(v10679)
                                                                                                                                                                                                    let v10827 : string option = method78(v10679)
                                                                                                                                                                                                    let v10828 : (string -> US1) = method4()
                                                                                                                                                                                                    let v10829 : US1 option = v10827 |> Option.map v10828 
                                                                                                                                                                                                    let v10840 : US1 = US1_1
                                                                                                                                                                                                    let v10841 : US1 = v10829 |> Option.defaultValue v10840 
                                                                                                                                                                                                    let v10845 : string = $"file_system.read_link / path: {v1} / n: {11uy} / path': {v10679} / name: {v10826}"
                                                                                                                                                                                                    let v10846 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v10847 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v10848 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10845 v10847 
                                                                                                                                                                                                    let _v10846 = v10848 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v10849 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v10850 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10845 v10849 
                                                                                                                                                                                                    let _v10846 = v10850 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v10851 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                    let v10852 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10845 v10851 
                                                                                                                                                                                                    let _v10846 = v10852 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v10853 : std_io_Error = v10845 
                                                                                                                                                                                                    let _v10846 = v10853 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v10854 : std_io_Error = v10845 
                                                                                                                                                                                                    let _v10846 = v10854 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v10855 : std_io_Error = v10845 
                                                                                                                                                                                                    let _v10846 = v10855 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v10856 : std_io_Error = _v10846 
                                                                                                                                                                                                    let v10859 : unit = ()
                                                                                                                                                                                                    
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                    
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                    let v10860 : string = "Err($0)"
                                                                                                                                                                                                    let v10861 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10856 v10860 
                                                                                                                                                                                                    let _v10859 = v10861 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                    let v10862 : string = "Err($0)"
                                                                                                                                                                                                    let v10863 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10856 v10862 
                                                                                                                                                                                                    let _v10859 = v10863 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                    let v10864 : string = "Err($0)"
                                                                                                                                                                                                    let v10865 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10856 v10864 
                                                                                                                                                                                                    let _v10859 = v10865 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                    let v10866 : Result<std_path_PathBuf, std_io_Error> = v10856 |> Error
                                                                                                                                                                                                    let _v10859 = v10866 
                                                                                                                                                                                                    #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                    let v10867 : Result<std_path_PathBuf, std_io_Error> = v10856 |> Error
                                                                                                                                                                                                    let _v10859 = v10867 
                                                                                                                                                                                                    #endif
#else
                                                                                                                                                                                                    let v10868 : Result<std_path_PathBuf, std_io_Error> = v10856 |> Error
                                                                                                                                                                                                    let _v10859 = v10868 
                                                                                                                                                                                                    #endif
                                                                                                                                                                                                    let v10869 : Result<std_path_PathBuf, std_io_Error> = _v10859 
                                                                                                                                                                                                    v10869
                                                                                                                                                                                            let v10873 : (std_io_Error -> string) = method76()
                                                                                                                                                                                            let v10874 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v10875 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v10876 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v10872, v10873) v10875 
                                                                                                                                                                                            let _v10874 = v10876 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v10877 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v10878 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v10872, v10873) v10877 
                                                                                                                                                                                            let _v10874 = v10878 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v10879 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                                            let v10880 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v10872, v10873) v10879 
                                                                                                                                                                                            let _v10874 = v10880 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v10881 : Result<std_path_PathBuf, string> = match v10872 with Ok x -> Ok x | Error x -> Error (v10873 x)
                                                                                                                                                                                            let _v10874 = v10881 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v10882 : Result<std_path_PathBuf, string> = match v10872 with Ok x -> Ok x | Error x -> Error (v10873 x)
                                                                                                                                                                                            let _v10874 = v10882 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v10883 : Result<std_path_PathBuf, string> = match v10872 with Ok x -> Ok x | Error x -> Error (v10873 x)
                                                                                                                                                                                            let _v10874 = v10883 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v10884 : Result<std_path_PathBuf, string> = _v10874 
                                                                                                                                                                                            let v10887 : (std_path_PathBuf -> US13) = closure47()
                                                                                                                                                                                            let v10888 : (string -> US13) = closure48()
                                                                                                                                                                                            let v10889 : US13 = match v10884 with Ok x -> v10887 x | Error x -> v10888 x
                                                                                                                                                                                            match v10889 with
                                                                                                                                                                                            | US13_1(v10992) -> (* Error *)
                                                                                                                                                                                                let v10993 : string = $"file_system.read_link / error': {v10992} / error: {v10657} / name: {v10660}"
                                                                                                                                                                                                let v10994 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10995 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v10996 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10993 v10995 
                                                                                                                                                                                                let _v10994 = v10996 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10997 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v10998 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10993 v10997 
                                                                                                                                                                                                let _v10994 = v10998 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10999 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                                let v11000 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v10993 v10999 
                                                                                                                                                                                                let _v10994 = v11000 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v11001 : std_io_Error = v10993 
                                                                                                                                                                                                let _v10994 = v11001 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v11002 : std_io_Error = v10993 
                                                                                                                                                                                                let _v10994 = v11002 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v11003 : std_io_Error = v10993 
                                                                                                                                                                                                let _v10994 = v11003 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v11004 : std_io_Error = _v10994 
                                                                                                                                                                                                let v11007 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v11008 : string = "Err($0)"
                                                                                                                                                                                                let v11009 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11004 v11008 
                                                                                                                                                                                                let _v11007 = v11009 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v11010 : string = "Err($0)"
                                                                                                                                                                                                let v11011 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11004 v11010 
                                                                                                                                                                                                let _v11007 = v11011 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v11012 : string = "Err($0)"
                                                                                                                                                                                                let v11013 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11004 v11012 
                                                                                                                                                                                                let _v11007 = v11013 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v11014 : Result<std_path_PathBuf, std_io_Error> = v11004 |> Error
                                                                                                                                                                                                let _v11007 = v11014 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v11015 : Result<std_path_PathBuf, std_io_Error> = v11004 |> Error
                                                                                                                                                                                                let _v11007 = v11015 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v11016 : Result<std_path_PathBuf, std_io_Error> = v11004 |> Error
                                                                                                                                                                                                let _v11007 = v11016 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v11017 : Result<std_path_PathBuf, std_io_Error> = _v11007 
                                                                                                                                                                                                v11017
                                                                                                                                                                                            | US13_0(v10890) -> (* Ok *)
                                                                                                                                                                                                let v10891 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10892 : string = "$0.display()"
                                                                                                                                                                                                let v10893 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v10890 v10892 
                                                                                                                                                                                                let _v10891 = v10893 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10894 : string = "$0.display()"
                                                                                                                                                                                                let v10895 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v10890 v10894 
                                                                                                                                                                                                let _v10891 = v10895 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10896 : string = "$0.display()"
                                                                                                                                                                                                let v10897 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v10890 v10896 
                                                                                                                                                                                                let _v10891 = v10897 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10898 : std_path_Display = v10890 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v10891 = v10898 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10901 : std_path_Display = v10890 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v10891 = v10901 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10904 : std_path_Display = v10890 |> unbox<std_path_Display>
                                                                                                                                                                                                let _v10891 = v10904 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10907 : std_path_Display = _v10891 
                                                                                                                                                                                                let v10912 : string = v10907 |> string 
                                                                                                                                                                                                let v10915 : string = method56(v10912, v10660)
                                                                                                                                                                                                let v10916 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10917 : string = "&*$0"
                                                                                                                                                                                                let v10918 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v10915 v10917 
                                                                                                                                                                                                let _v10916 = v10918 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10919 : string = "&*$0"
                                                                                                                                                                                                let v10920 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v10915 v10919 
                                                                                                                                                                                                let _v10916 = v10920 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10921 : string = "&*$0"
                                                                                                                                                                                                let v10922 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v10915 v10921 
                                                                                                                                                                                                let _v10916 = v10922 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10923 : Ref<Str> = v10915 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v10916 = v10923 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10926 : Ref<Str> = v10915 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v10916 = v10926 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10929 : Ref<Str> = v10915 |> unbox<Ref<Str>>
                                                                                                                                                                                                let _v10916 = v10929 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10932 : Ref<Str> = _v10916 
                                                                                                                                                                                                let v10937 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10938 : string = "String::from($0)"
                                                                                                                                                                                                let v10939 : std_string_String = Fable.Core.RustInterop.emitRustExpr v10932 v10938 
                                                                                                                                                                                                let _v10937 = v10939 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10940 : string = "String::from($0)"
                                                                                                                                                                                                let v10941 : std_string_String = Fable.Core.RustInterop.emitRustExpr v10932 v10940 
                                                                                                                                                                                                let _v10937 = v10941 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10942 : string = "String::from($0)"
                                                                                                                                                                                                let v10943 : std_string_String = Fable.Core.RustInterop.emitRustExpr v10932 v10942 
                                                                                                                                                                                                let _v10937 = v10943 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10944 : std_string_String = v10932 |> unbox<std_string_String>
                                                                                                                                                                                                let _v10937 = v10944 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10947 : std_string_String = v10932 |> unbox<std_string_String>
                                                                                                                                                                                                let _v10937 = v10947 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10950 : std_string_String = v10932 |> unbox<std_string_String>
                                                                                                                                                                                                let _v10937 = v10950 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10953 : std_string_String = _v10937 
                                                                                                                                                                                                let v10958 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10959 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v10960 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v10953 v10959 
                                                                                                                                                                                                let _v10958 = v10960 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10961 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v10962 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v10953 v10961 
                                                                                                                                                                                                let _v10958 = v10962 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10963 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                                let v10964 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v10953 v10963 
                                                                                                                                                                                                let _v10958 = v10964 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10965 : std_path_PathBuf = v10953 |> std_path_PathBuf 
                                                                                                                                                                                                let _v10958 = v10965 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10968 : std_path_PathBuf = v10953 |> std_path_PathBuf 
                                                                                                                                                                                                let _v10958 = v10968 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10971 : std_path_PathBuf = v10953 |> std_path_PathBuf 
                                                                                                                                                                                                let _v10958 = v10971 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10974 : std_path_PathBuf = _v10958 
                                                                                                                                                                                                let v10979 : unit = ()
                                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                                let v10980 : string = "Ok($0)"
                                                                                                                                                                                                let v10981 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10974 v10980 
                                                                                                                                                                                                let _v10979 = v10981 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                                let v10982 : string = "Ok($0)"
                                                                                                                                                                                                let v10983 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10974 v10982 
                                                                                                                                                                                                let _v10979 = v10983 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                                let v10984 : string = "Ok($0)"
                                                                                                                                                                                                let v10985 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v10974 v10984 
                                                                                                                                                                                                let _v10979 = v10985 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                                let v10986 : Result<std_path_PathBuf, std_io_Error> = v10974 |> Ok
                                                                                                                                                                                                let _v10979 = v10986 
                                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                                let v10987 : Result<std_path_PathBuf, std_io_Error> = v10974 |> Ok
                                                                                                                                                                                                let _v10979 = v10987 
                                                                                                                                                                                                #endif
#else
                                                                                                                                                                                                let v10988 : Result<std_path_PathBuf, std_io_Error> = v10974 |> Ok
                                                                                                                                                                                                let _v10979 = v10988 
                                                                                                                                                                                                #endif
                                                                                                                                                                                                let v10989 : Result<std_path_PathBuf, std_io_Error> = _v10979 
                                                                                                                                                                                                v10989
                                                                                                                                                                                        else
                                                                                                                                                                                            let v11022 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v10657} / path': {v10513} / name: {v10660}"
                                                                                                                                                                                            let v11023 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v11024 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v11025 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11022 v11024 
                                                                                                                                                                                            let _v11023 = v11025 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v11026 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v11027 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11022 v11026 
                                                                                                                                                                                            let _v11023 = v11027 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v11028 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                            let v11029 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11022 v11028 
                                                                                                                                                                                            let _v11023 = v11029 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v11030 : std_io_Error = v11022 
                                                                                                                                                                                            let _v11023 = v11030 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v11031 : std_io_Error = v11022 
                                                                                                                                                                                            let _v11023 = v11031 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v11032 : std_io_Error = v11022 
                                                                                                                                                                                            let _v11023 = v11032 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v11033 : std_io_Error = _v11023 
                                                                                                                                                                                            let v11036 : unit = ()
                                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                            let v11037 : string = "Err($0)"
                                                                                                                                                                                            let v11038 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11033 v11037 
                                                                                                                                                                                            let _v11036 = v11038 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                            let v11039 : string = "Err($0)"
                                                                                                                                                                                            let v11040 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11033 v11039 
                                                                                                                                                                                            let _v11036 = v11040 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                            let v11041 : string = "Err($0)"
                                                                                                                                                                                            let v11042 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11033 v11041 
                                                                                                                                                                                            let _v11036 = v11042 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                            let v11043 : Result<std_path_PathBuf, std_io_Error> = v11033 |> Error
                                                                                                                                                                                            let _v11036 = v11043 
                                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                            let v11044 : Result<std_path_PathBuf, std_io_Error> = v11033 |> Error
                                                                                                                                                                                            let _v11036 = v11044 
                                                                                                                                                                                            #endif
#else
                                                                                                                                                                                            let v11045 : Result<std_path_PathBuf, std_io_Error> = v11033 |> Error
                                                                                                                                                                                            let _v11036 = v11045 
                                                                                                                                                                                            #endif
                                                                                                                                                                                            let v11046 : Result<std_path_PathBuf, std_io_Error> = _v11036 
                                                                                                                                                                                            v11046
                                                                                                                                                                                    | _ ->
                                                                                                                                                                                        let v11050 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v10657} / path': {v10513} / name: {v10660}"
                                                                                                                                                                                        let v11051 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v11052 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v11053 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11050 v11052 
                                                                                                                                                                                        let _v11051 = v11053 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v11054 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v11055 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11050 v11054 
                                                                                                                                                                                        let _v11051 = v11055 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v11056 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                        let v11057 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11050 v11056 
                                                                                                                                                                                        let _v11051 = v11057 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v11058 : std_io_Error = v11050 
                                                                                                                                                                                        let _v11051 = v11058 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v11059 : std_io_Error = v11050 
                                                                                                                                                                                        let _v11051 = v11059 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v11060 : std_io_Error = v11050 
                                                                                                                                                                                        let _v11051 = v11060 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v11061 : std_io_Error = _v11051 
                                                                                                                                                                                        let v11064 : unit = ()
                                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                        let v11065 : string = "Err($0)"
                                                                                                                                                                                        let v11066 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11061 v11065 
                                                                                                                                                                                        let _v11064 = v11066 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                        let v11067 : string = "Err($0)"
                                                                                                                                                                                        let v11068 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11061 v11067 
                                                                                                                                                                                        let _v11064 = v11068 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                        let v11069 : string = "Err($0)"
                                                                                                                                                                                        let v11070 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11061 v11069 
                                                                                                                                                                                        let _v11064 = v11070 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                        let v11071 : Result<std_path_PathBuf, std_io_Error> = v11061 |> Error
                                                                                                                                                                                        let _v11064 = v11071 
                                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                        let v11072 : Result<std_path_PathBuf, std_io_Error> = v11061 |> Error
                                                                                                                                                                                        let _v11064 = v11072 
                                                                                                                                                                                        #endif
#else
                                                                                                                                                                                        let v11073 : Result<std_path_PathBuf, std_io_Error> = v11061 |> Error
                                                                                                                                                                                        let _v11064 = v11073 
                                                                                                                                                                                        #endif
                                                                                                                                                                                        let v11074 : Result<std_path_PathBuf, std_io_Error> = _v11064 
                                                                                                                                                                                        v11074
                                                                                                                                                                            let v11079 : (std_io_Error -> string) = method76()
                                                                                                                                                                            let v11080 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11081 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v11082 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11078, v11079) v11081 
                                                                                                                                                                            let _v11080 = v11082 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11083 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v11084 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11078, v11079) v11083 
                                                                                                                                                                            let _v11080 = v11084 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11085 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                                            let v11086 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11078, v11079) v11085 
                                                                                                                                                                            let _v11080 = v11086 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11087 : Result<std_path_PathBuf, string> = match v11078 with Ok x -> Ok x | Error x -> Error (v11079 x)
                                                                                                                                                                            let _v11080 = v11087 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11088 : Result<std_path_PathBuf, string> = match v11078 with Ok x -> Ok x | Error x -> Error (v11079 x)
                                                                                                                                                                            let _v11080 = v11088 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11089 : Result<std_path_PathBuf, string> = match v11078 with Ok x -> Ok x | Error x -> Error (v11079 x)
                                                                                                                                                                            let _v11080 = v11089 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11090 : Result<std_path_PathBuf, string> = _v11080 
                                                                                                                                                                            let v11093 : (std_path_PathBuf -> US13) = closure47()
                                                                                                                                                                            let v11094 : (string -> US13) = closure48()
                                                                                                                                                                            let v11095 : US13 = match v11090 with Ok x -> v11093 x | Error x -> v11094 x
                                                                                                                                                                            match v11095 with
                                                                                                                                                                            | US13_1(v11198) -> (* Error *)
                                                                                                                                                                                let v11199 : string = $"file_system.read_link / error': {v11198} / error: {v10491} / name: {v10494}"
                                                                                                                                                                                let v11200 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v11201 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v11202 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11199 v11201 
                                                                                                                                                                                let _v11200 = v11202 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v11203 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v11204 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11199 v11203 
                                                                                                                                                                                let _v11200 = v11204 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v11205 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                                let v11206 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11199 v11205 
                                                                                                                                                                                let _v11200 = v11206 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v11207 : std_io_Error = v11199 
                                                                                                                                                                                let _v11200 = v11207 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v11208 : std_io_Error = v11199 
                                                                                                                                                                                let _v11200 = v11208 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v11209 : std_io_Error = v11199 
                                                                                                                                                                                let _v11200 = v11209 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v11210 : std_io_Error = _v11200 
                                                                                                                                                                                let v11213 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v11214 : string = "Err($0)"
                                                                                                                                                                                let v11215 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11210 v11214 
                                                                                                                                                                                let _v11213 = v11215 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v11216 : string = "Err($0)"
                                                                                                                                                                                let v11217 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11210 v11216 
                                                                                                                                                                                let _v11213 = v11217 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v11218 : string = "Err($0)"
                                                                                                                                                                                let v11219 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11210 v11218 
                                                                                                                                                                                let _v11213 = v11219 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v11220 : Result<std_path_PathBuf, std_io_Error> = v11210 |> Error
                                                                                                                                                                                let _v11213 = v11220 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v11221 : Result<std_path_PathBuf, std_io_Error> = v11210 |> Error
                                                                                                                                                                                let _v11213 = v11221 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v11222 : Result<std_path_PathBuf, std_io_Error> = v11210 |> Error
                                                                                                                                                                                let _v11213 = v11222 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v11223 : Result<std_path_PathBuf, std_io_Error> = _v11213 
                                                                                                                                                                                v11223
                                                                                                                                                                            | US13_0(v11096) -> (* Ok *)
                                                                                                                                                                                let v11097 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v11098 : string = "$0.display()"
                                                                                                                                                                                let v11099 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11096 v11098 
                                                                                                                                                                                let _v11097 = v11099 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v11100 : string = "$0.display()"
                                                                                                                                                                                let v11101 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11096 v11100 
                                                                                                                                                                                let _v11097 = v11101 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v11102 : string = "$0.display()"
                                                                                                                                                                                let v11103 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11096 v11102 
                                                                                                                                                                                let _v11097 = v11103 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v11104 : std_path_Display = v11096 |> unbox<std_path_Display>
                                                                                                                                                                                let _v11097 = v11104 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v11107 : std_path_Display = v11096 |> unbox<std_path_Display>
                                                                                                                                                                                let _v11097 = v11107 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v11110 : std_path_Display = v11096 |> unbox<std_path_Display>
                                                                                                                                                                                let _v11097 = v11110 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v11113 : std_path_Display = _v11097 
                                                                                                                                                                                let v11118 : string = v11113 |> string 
                                                                                                                                                                                let v11121 : string = method56(v11118, v10494)
                                                                                                                                                                                let v11122 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v11123 : string = "&*$0"
                                                                                                                                                                                let v11124 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11121 v11123 
                                                                                                                                                                                let _v11122 = v11124 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v11125 : string = "&*$0"
                                                                                                                                                                                let v11126 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11121 v11125 
                                                                                                                                                                                let _v11122 = v11126 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v11127 : string = "&*$0"
                                                                                                                                                                                let v11128 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11121 v11127 
                                                                                                                                                                                let _v11122 = v11128 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v11129 : Ref<Str> = v11121 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v11122 = v11129 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v11132 : Ref<Str> = v11121 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v11122 = v11132 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v11135 : Ref<Str> = v11121 |> unbox<Ref<Str>>
                                                                                                                                                                                let _v11122 = v11135 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v11138 : Ref<Str> = _v11122 
                                                                                                                                                                                let v11143 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v11144 : string = "String::from($0)"
                                                                                                                                                                                let v11145 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11138 v11144 
                                                                                                                                                                                let _v11143 = v11145 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v11146 : string = "String::from($0)"
                                                                                                                                                                                let v11147 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11138 v11146 
                                                                                                                                                                                let _v11143 = v11147 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v11148 : string = "String::from($0)"
                                                                                                                                                                                let v11149 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11138 v11148 
                                                                                                                                                                                let _v11143 = v11149 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v11150 : std_string_String = v11138 |> unbox<std_string_String>
                                                                                                                                                                                let _v11143 = v11150 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v11153 : std_string_String = v11138 |> unbox<std_string_String>
                                                                                                                                                                                let _v11143 = v11153 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v11156 : std_string_String = v11138 |> unbox<std_string_String>
                                                                                                                                                                                let _v11143 = v11156 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v11159 : std_string_String = _v11143 
                                                                                                                                                                                let v11164 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v11165 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v11166 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11159 v11165 
                                                                                                                                                                                let _v11164 = v11166 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v11167 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v11168 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11159 v11167 
                                                                                                                                                                                let _v11164 = v11168 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v11169 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                                let v11170 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11159 v11169 
                                                                                                                                                                                let _v11164 = v11170 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v11171 : std_path_PathBuf = v11159 |> std_path_PathBuf 
                                                                                                                                                                                let _v11164 = v11171 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v11174 : std_path_PathBuf = v11159 |> std_path_PathBuf 
                                                                                                                                                                                let _v11164 = v11174 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v11177 : std_path_PathBuf = v11159 |> std_path_PathBuf 
                                                                                                                                                                                let _v11164 = v11177 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v11180 : std_path_PathBuf = _v11164 
                                                                                                                                                                                let v11185 : unit = ()
                                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                                let v11186 : string = "Ok($0)"
                                                                                                                                                                                let v11187 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11180 v11186 
                                                                                                                                                                                let _v11185 = v11187 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                                let v11188 : string = "Ok($0)"
                                                                                                                                                                                let v11189 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11180 v11188 
                                                                                                                                                                                let _v11185 = v11189 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                                let v11190 : string = "Ok($0)"
                                                                                                                                                                                let v11191 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11180 v11190 
                                                                                                                                                                                let _v11185 = v11191 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                                let v11192 : Result<std_path_PathBuf, std_io_Error> = v11180 |> Ok
                                                                                                                                                                                let _v11185 = v11192 
                                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                                let v11193 : Result<std_path_PathBuf, std_io_Error> = v11180 |> Ok
                                                                                                                                                                                let _v11185 = v11193 
                                                                                                                                                                                #endif
#else
                                                                                                                                                                                let v11194 : Result<std_path_PathBuf, std_io_Error> = v11180 |> Ok
                                                                                                                                                                                let _v11185 = v11194 
                                                                                                                                                                                #endif
                                                                                                                                                                                let v11195 : Result<std_path_PathBuf, std_io_Error> = _v11185 
                                                                                                                                                                                v11195
                                                                                                                                                                        else
                                                                                                                                                                            let v11228 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v10491} / path': {v10347} / name: {v10494}"
                                                                                                                                                                            let v11229 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11230 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v11231 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11228 v11230 
                                                                                                                                                                            let _v11229 = v11231 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11232 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v11233 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11228 v11232 
                                                                                                                                                                            let _v11229 = v11233 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11234 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                            let v11235 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11228 v11234 
                                                                                                                                                                            let _v11229 = v11235 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11236 : std_io_Error = v11228 
                                                                                                                                                                            let _v11229 = v11236 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11237 : std_io_Error = v11228 
                                                                                                                                                                            let _v11229 = v11237 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11238 : std_io_Error = v11228 
                                                                                                                                                                            let _v11229 = v11238 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11239 : std_io_Error = _v11229 
                                                                                                                                                                            let v11242 : unit = ()
                                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                            let v11243 : string = "Err($0)"
                                                                                                                                                                            let v11244 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11239 v11243 
                                                                                                                                                                            let _v11242 = v11244 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                            let v11245 : string = "Err($0)"
                                                                                                                                                                            let v11246 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11239 v11245 
                                                                                                                                                                            let _v11242 = v11246 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                            let v11247 : string = "Err($0)"
                                                                                                                                                                            let v11248 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11239 v11247 
                                                                                                                                                                            let _v11242 = v11248 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                            let v11249 : Result<std_path_PathBuf, std_io_Error> = v11239 |> Error
                                                                                                                                                                            let _v11242 = v11249 
                                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                            let v11250 : Result<std_path_PathBuf, std_io_Error> = v11239 |> Error
                                                                                                                                                                            let _v11242 = v11250 
                                                                                                                                                                            #endif
#else
                                                                                                                                                                            let v11251 : Result<std_path_PathBuf, std_io_Error> = v11239 |> Error
                                                                                                                                                                            let _v11242 = v11251 
                                                                                                                                                                            #endif
                                                                                                                                                                            let v11252 : Result<std_path_PathBuf, std_io_Error> = _v11242 
                                                                                                                                                                            v11252
                                                                                                                                                                    | _ ->
                                                                                                                                                                        let v11256 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v10491} / path': {v10347} / name: {v10494}"
                                                                                                                                                                        let v11257 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v11258 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v11259 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11256 v11258 
                                                                                                                                                                        let _v11257 = v11259 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v11260 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v11261 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11256 v11260 
                                                                                                                                                                        let _v11257 = v11261 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v11262 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                        let v11263 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11256 v11262 
                                                                                                                                                                        let _v11257 = v11263 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v11264 : std_io_Error = v11256 
                                                                                                                                                                        let _v11257 = v11264 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v11265 : std_io_Error = v11256 
                                                                                                                                                                        let _v11257 = v11265 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v11266 : std_io_Error = v11256 
                                                                                                                                                                        let _v11257 = v11266 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v11267 : std_io_Error = _v11257 
                                                                                                                                                                        let v11270 : unit = ()
                                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                        let v11271 : string = "Err($0)"
                                                                                                                                                                        let v11272 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11267 v11271 
                                                                                                                                                                        let _v11270 = v11272 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                        let v11273 : string = "Err($0)"
                                                                                                                                                                        let v11274 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11267 v11273 
                                                                                                                                                                        let _v11270 = v11274 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                        let v11275 : string = "Err($0)"
                                                                                                                                                                        let v11276 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11267 v11275 
                                                                                                                                                                        let _v11270 = v11276 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                        let v11277 : Result<std_path_PathBuf, std_io_Error> = v11267 |> Error
                                                                                                                                                                        let _v11270 = v11277 
                                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                        let v11278 : Result<std_path_PathBuf, std_io_Error> = v11267 |> Error
                                                                                                                                                                        let _v11270 = v11278 
                                                                                                                                                                        #endif
#else
                                                                                                                                                                        let v11279 : Result<std_path_PathBuf, std_io_Error> = v11267 |> Error
                                                                                                                                                                        let _v11270 = v11279 
                                                                                                                                                                        #endif
                                                                                                                                                                        let v11280 : Result<std_path_PathBuf, std_io_Error> = _v11270 
                                                                                                                                                                        v11280
                                                                                                                                                            let v11285 : (std_io_Error -> string) = method76()
                                                                                                                                                            let v11286 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11287 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v11288 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11284, v11285) v11287 
                                                                                                                                                            let _v11286 = v11288 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11289 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v11290 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11284, v11285) v11289 
                                                                                                                                                            let _v11286 = v11290 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11291 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                                            let v11292 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11284, v11285) v11291 
                                                                                                                                                            let _v11286 = v11292 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11293 : Result<std_path_PathBuf, string> = match v11284 with Ok x -> Ok x | Error x -> Error (v11285 x)
                                                                                                                                                            let _v11286 = v11293 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11294 : Result<std_path_PathBuf, string> = match v11284 with Ok x -> Ok x | Error x -> Error (v11285 x)
                                                                                                                                                            let _v11286 = v11294 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11295 : Result<std_path_PathBuf, string> = match v11284 with Ok x -> Ok x | Error x -> Error (v11285 x)
                                                                                                                                                            let _v11286 = v11295 
                                                                                                                                                            #endif
                                                                                                                                                            let v11296 : Result<std_path_PathBuf, string> = _v11286 
                                                                                                                                                            let v11299 : (std_path_PathBuf -> US13) = closure47()
                                                                                                                                                            let v11300 : (string -> US13) = closure48()
                                                                                                                                                            let v11301 : US13 = match v11296 with Ok x -> v11299 x | Error x -> v11300 x
                                                                                                                                                            match v11301 with
                                                                                                                                                            | US13_1(v11404) -> (* Error *)
                                                                                                                                                                let v11405 : string = $"file_system.read_link / error': {v11404} / error: {v10325} / name: {v10328}"
                                                                                                                                                                let v11406 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v11407 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v11408 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11405 v11407 
                                                                                                                                                                let _v11406 = v11408 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v11409 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v11410 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11405 v11409 
                                                                                                                                                                let _v11406 = v11410 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v11411 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                                let v11412 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11405 v11411 
                                                                                                                                                                let _v11406 = v11412 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v11413 : std_io_Error = v11405 
                                                                                                                                                                let _v11406 = v11413 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v11414 : std_io_Error = v11405 
                                                                                                                                                                let _v11406 = v11414 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v11415 : std_io_Error = v11405 
                                                                                                                                                                let _v11406 = v11415 
                                                                                                                                                                #endif
                                                                                                                                                                let v11416 : std_io_Error = _v11406 
                                                                                                                                                                let v11419 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v11420 : string = "Err($0)"
                                                                                                                                                                let v11421 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11416 v11420 
                                                                                                                                                                let _v11419 = v11421 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v11422 : string = "Err($0)"
                                                                                                                                                                let v11423 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11416 v11422 
                                                                                                                                                                let _v11419 = v11423 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v11424 : string = "Err($0)"
                                                                                                                                                                let v11425 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11416 v11424 
                                                                                                                                                                let _v11419 = v11425 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v11426 : Result<std_path_PathBuf, std_io_Error> = v11416 |> Error
                                                                                                                                                                let _v11419 = v11426 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v11427 : Result<std_path_PathBuf, std_io_Error> = v11416 |> Error
                                                                                                                                                                let _v11419 = v11427 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v11428 : Result<std_path_PathBuf, std_io_Error> = v11416 |> Error
                                                                                                                                                                let _v11419 = v11428 
                                                                                                                                                                #endif
                                                                                                                                                                let v11429 : Result<std_path_PathBuf, std_io_Error> = _v11419 
                                                                                                                                                                v11429
                                                                                                                                                            | US13_0(v11302) -> (* Ok *)
                                                                                                                                                                let v11303 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v11304 : string = "$0.display()"
                                                                                                                                                                let v11305 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11302 v11304 
                                                                                                                                                                let _v11303 = v11305 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v11306 : string = "$0.display()"
                                                                                                                                                                let v11307 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11302 v11306 
                                                                                                                                                                let _v11303 = v11307 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v11308 : string = "$0.display()"
                                                                                                                                                                let v11309 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11302 v11308 
                                                                                                                                                                let _v11303 = v11309 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v11310 : std_path_Display = v11302 |> unbox<std_path_Display>
                                                                                                                                                                let _v11303 = v11310 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v11313 : std_path_Display = v11302 |> unbox<std_path_Display>
                                                                                                                                                                let _v11303 = v11313 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v11316 : std_path_Display = v11302 |> unbox<std_path_Display>
                                                                                                                                                                let _v11303 = v11316 
                                                                                                                                                                #endif
                                                                                                                                                                let v11319 : std_path_Display = _v11303 
                                                                                                                                                                let v11324 : string = v11319 |> string 
                                                                                                                                                                let v11327 : string = method56(v11324, v10328)
                                                                                                                                                                let v11328 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v11329 : string = "&*$0"
                                                                                                                                                                let v11330 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11327 v11329 
                                                                                                                                                                let _v11328 = v11330 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v11331 : string = "&*$0"
                                                                                                                                                                let v11332 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11327 v11331 
                                                                                                                                                                let _v11328 = v11332 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v11333 : string = "&*$0"
                                                                                                                                                                let v11334 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11327 v11333 
                                                                                                                                                                let _v11328 = v11334 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v11335 : Ref<Str> = v11327 |> unbox<Ref<Str>>
                                                                                                                                                                let _v11328 = v11335 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v11338 : Ref<Str> = v11327 |> unbox<Ref<Str>>
                                                                                                                                                                let _v11328 = v11338 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v11341 : Ref<Str> = v11327 |> unbox<Ref<Str>>
                                                                                                                                                                let _v11328 = v11341 
                                                                                                                                                                #endif
                                                                                                                                                                let v11344 : Ref<Str> = _v11328 
                                                                                                                                                                let v11349 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v11350 : string = "String::from($0)"
                                                                                                                                                                let v11351 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11344 v11350 
                                                                                                                                                                let _v11349 = v11351 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v11352 : string = "String::from($0)"
                                                                                                                                                                let v11353 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11344 v11352 
                                                                                                                                                                let _v11349 = v11353 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v11354 : string = "String::from($0)"
                                                                                                                                                                let v11355 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11344 v11354 
                                                                                                                                                                let _v11349 = v11355 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v11356 : std_string_String = v11344 |> unbox<std_string_String>
                                                                                                                                                                let _v11349 = v11356 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v11359 : std_string_String = v11344 |> unbox<std_string_String>
                                                                                                                                                                let _v11349 = v11359 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v11362 : std_string_String = v11344 |> unbox<std_string_String>
                                                                                                                                                                let _v11349 = v11362 
                                                                                                                                                                #endif
                                                                                                                                                                let v11365 : std_string_String = _v11349 
                                                                                                                                                                let v11370 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v11371 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v11372 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11365 v11371 
                                                                                                                                                                let _v11370 = v11372 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v11373 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v11374 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11365 v11373 
                                                                                                                                                                let _v11370 = v11374 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v11375 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                                let v11376 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11365 v11375 
                                                                                                                                                                let _v11370 = v11376 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v11377 : std_path_PathBuf = v11365 |> std_path_PathBuf 
                                                                                                                                                                let _v11370 = v11377 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v11380 : std_path_PathBuf = v11365 |> std_path_PathBuf 
                                                                                                                                                                let _v11370 = v11380 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v11383 : std_path_PathBuf = v11365 |> std_path_PathBuf 
                                                                                                                                                                let _v11370 = v11383 
                                                                                                                                                                #endif
                                                                                                                                                                let v11386 : std_path_PathBuf = _v11370 
                                                                                                                                                                let v11391 : unit = ()
                                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                                let v11392 : string = "Ok($0)"
                                                                                                                                                                let v11393 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11386 v11392 
                                                                                                                                                                let _v11391 = v11393 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                                let v11394 : string = "Ok($0)"
                                                                                                                                                                let v11395 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11386 v11394 
                                                                                                                                                                let _v11391 = v11395 
                                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                                let v11396 : string = "Ok($0)"
                                                                                                                                                                let v11397 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11386 v11396 
                                                                                                                                                                let _v11391 = v11397 
                                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                                let v11398 : Result<std_path_PathBuf, std_io_Error> = v11386 |> Ok
                                                                                                                                                                let _v11391 = v11398 
                                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                                let v11399 : Result<std_path_PathBuf, std_io_Error> = v11386 |> Ok
                                                                                                                                                                let _v11391 = v11399 
                                                                                                                                                                #endif
#else
                                                                                                                                                                let v11400 : Result<std_path_PathBuf, std_io_Error> = v11386 |> Ok
                                                                                                                                                                let _v11391 = v11400 
                                                                                                                                                                #endif
                                                                                                                                                                let v11401 : Result<std_path_PathBuf, std_io_Error> = _v11391 
                                                                                                                                                                v11401
                                                                                                                                                        else
                                                                                                                                                            let v11434 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v10325} / path': {v10181} / name: {v10328}"
                                                                                                                                                            let v11435 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11436 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v11437 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11434 v11436 
                                                                                                                                                            let _v11435 = v11437 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11438 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v11439 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11434 v11438 
                                                                                                                                                            let _v11435 = v11439 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11440 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                            let v11441 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11434 v11440 
                                                                                                                                                            let _v11435 = v11441 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11442 : std_io_Error = v11434 
                                                                                                                                                            let _v11435 = v11442 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11443 : std_io_Error = v11434 
                                                                                                                                                            let _v11435 = v11443 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11444 : std_io_Error = v11434 
                                                                                                                                                            let _v11435 = v11444 
                                                                                                                                                            #endif
                                                                                                                                                            let v11445 : std_io_Error = _v11435 
                                                                                                                                                            let v11448 : unit = ()
                                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                            let v11449 : string = "Err($0)"
                                                                                                                                                            let v11450 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11445 v11449 
                                                                                                                                                            let _v11448 = v11450 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                            let v11451 : string = "Err($0)"
                                                                                                                                                            let v11452 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11445 v11451 
                                                                                                                                                            let _v11448 = v11452 
                                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                            let v11453 : string = "Err($0)"
                                                                                                                                                            let v11454 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11445 v11453 
                                                                                                                                                            let _v11448 = v11454 
                                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                            let v11455 : Result<std_path_PathBuf, std_io_Error> = v11445 |> Error
                                                                                                                                                            let _v11448 = v11455 
                                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                            let v11456 : Result<std_path_PathBuf, std_io_Error> = v11445 |> Error
                                                                                                                                                            let _v11448 = v11456 
                                                                                                                                                            #endif
#else
                                                                                                                                                            let v11457 : Result<std_path_PathBuf, std_io_Error> = v11445 |> Error
                                                                                                                                                            let _v11448 = v11457 
                                                                                                                                                            #endif
                                                                                                                                                            let v11458 : Result<std_path_PathBuf, std_io_Error> = _v11448 
                                                                                                                                                            v11458
                                                                                                                                                    | _ ->
                                                                                                                                                        let v11462 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v10325} / path': {v10181} / name: {v10328}"
                                                                                                                                                        let v11463 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v11464 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v11465 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11462 v11464 
                                                                                                                                                        let _v11463 = v11465 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v11466 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v11467 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11462 v11466 
                                                                                                                                                        let _v11463 = v11467 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v11468 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                        let v11469 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11462 v11468 
                                                                                                                                                        let _v11463 = v11469 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v11470 : std_io_Error = v11462 
                                                                                                                                                        let _v11463 = v11470 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v11471 : std_io_Error = v11462 
                                                                                                                                                        let _v11463 = v11471 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v11472 : std_io_Error = v11462 
                                                                                                                                                        let _v11463 = v11472 
                                                                                                                                                        #endif
                                                                                                                                                        let v11473 : std_io_Error = _v11463 
                                                                                                                                                        let v11476 : unit = ()
                                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                        let v11477 : string = "Err($0)"
                                                                                                                                                        let v11478 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11473 v11477 
                                                                                                                                                        let _v11476 = v11478 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                        let v11479 : string = "Err($0)"
                                                                                                                                                        let v11480 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11473 v11479 
                                                                                                                                                        let _v11476 = v11480 
                                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                        let v11481 : string = "Err($0)"
                                                                                                                                                        let v11482 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11473 v11481 
                                                                                                                                                        let _v11476 = v11482 
                                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                        let v11483 : Result<std_path_PathBuf, std_io_Error> = v11473 |> Error
                                                                                                                                                        let _v11476 = v11483 
                                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                        let v11484 : Result<std_path_PathBuf, std_io_Error> = v11473 |> Error
                                                                                                                                                        let _v11476 = v11484 
                                                                                                                                                        #endif
#else
                                                                                                                                                        let v11485 : Result<std_path_PathBuf, std_io_Error> = v11473 |> Error
                                                                                                                                                        let _v11476 = v11485 
                                                                                                                                                        #endif
                                                                                                                                                        let v11486 : Result<std_path_PathBuf, std_io_Error> = _v11476 
                                                                                                                                                        v11486
                                                                                                                                            let v11491 : (std_io_Error -> string) = method76()
                                                                                                                                            let v11492 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11493 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v11494 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11490, v11491) v11493 
                                                                                                                                            let _v11492 = v11494 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11495 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v11496 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11490, v11491) v11495 
                                                                                                                                            let _v11492 = v11496 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11497 : string = "$0.map_err(|x| $1(x))"
                                                                                                                                            let v11498 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11490, v11491) v11497 
                                                                                                                                            let _v11492 = v11498 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11499 : Result<std_path_PathBuf, string> = match v11490 with Ok x -> Ok x | Error x -> Error (v11491 x)
                                                                                                                                            let _v11492 = v11499 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11500 : Result<std_path_PathBuf, string> = match v11490 with Ok x -> Ok x | Error x -> Error (v11491 x)
                                                                                                                                            let _v11492 = v11500 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11501 : Result<std_path_PathBuf, string> = match v11490 with Ok x -> Ok x | Error x -> Error (v11491 x)
                                                                                                                                            let _v11492 = v11501 
                                                                                                                                            #endif
                                                                                                                                            let v11502 : Result<std_path_PathBuf, string> = _v11492 
                                                                                                                                            let v11505 : (std_path_PathBuf -> US13) = closure47()
                                                                                                                                            let v11506 : (string -> US13) = closure48()
                                                                                                                                            let v11507 : US13 = match v11502 with Ok x -> v11505 x | Error x -> v11506 x
                                                                                                                                            match v11507 with
                                                                                                                                            | US13_1(v11610) -> (* Error *)
                                                                                                                                                let v11611 : string = $"file_system.read_link / error': {v11610} / error: {v10159} / name: {v10162}"
                                                                                                                                                let v11612 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v11613 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v11614 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11611 v11613 
                                                                                                                                                let _v11612 = v11614 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v11615 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v11616 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11611 v11615 
                                                                                                                                                let _v11612 = v11616 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v11617 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                                let v11618 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11611 v11617 
                                                                                                                                                let _v11612 = v11618 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v11619 : std_io_Error = v11611 
                                                                                                                                                let _v11612 = v11619 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v11620 : std_io_Error = v11611 
                                                                                                                                                let _v11612 = v11620 
                                                                                                                                                #endif
#else
                                                                                                                                                let v11621 : std_io_Error = v11611 
                                                                                                                                                let _v11612 = v11621 
                                                                                                                                                #endif
                                                                                                                                                let v11622 : std_io_Error = _v11612 
                                                                                                                                                let v11625 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v11626 : string = "Err($0)"
                                                                                                                                                let v11627 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11622 v11626 
                                                                                                                                                let _v11625 = v11627 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v11628 : string = "Err($0)"
                                                                                                                                                let v11629 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11622 v11628 
                                                                                                                                                let _v11625 = v11629 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v11630 : string = "Err($0)"
                                                                                                                                                let v11631 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11622 v11630 
                                                                                                                                                let _v11625 = v11631 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v11632 : Result<std_path_PathBuf, std_io_Error> = v11622 |> Error
                                                                                                                                                let _v11625 = v11632 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v11633 : Result<std_path_PathBuf, std_io_Error> = v11622 |> Error
                                                                                                                                                let _v11625 = v11633 
                                                                                                                                                #endif
#else
                                                                                                                                                let v11634 : Result<std_path_PathBuf, std_io_Error> = v11622 |> Error
                                                                                                                                                let _v11625 = v11634 
                                                                                                                                                #endif
                                                                                                                                                let v11635 : Result<std_path_PathBuf, std_io_Error> = _v11625 
                                                                                                                                                v11635
                                                                                                                                            | US13_0(v11508) -> (* Ok *)
                                                                                                                                                let v11509 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v11510 : string = "$0.display()"
                                                                                                                                                let v11511 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11508 v11510 
                                                                                                                                                let _v11509 = v11511 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v11512 : string = "$0.display()"
                                                                                                                                                let v11513 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11508 v11512 
                                                                                                                                                let _v11509 = v11513 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v11514 : string = "$0.display()"
                                                                                                                                                let v11515 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11508 v11514 
                                                                                                                                                let _v11509 = v11515 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v11516 : std_path_Display = v11508 |> unbox<std_path_Display>
                                                                                                                                                let _v11509 = v11516 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v11519 : std_path_Display = v11508 |> unbox<std_path_Display>
                                                                                                                                                let _v11509 = v11519 
                                                                                                                                                #endif
#else
                                                                                                                                                let v11522 : std_path_Display = v11508 |> unbox<std_path_Display>
                                                                                                                                                let _v11509 = v11522 
                                                                                                                                                #endif
                                                                                                                                                let v11525 : std_path_Display = _v11509 
                                                                                                                                                let v11530 : string = v11525 |> string 
                                                                                                                                                let v11533 : string = method56(v11530, v10162)
                                                                                                                                                let v11534 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v11535 : string = "&*$0"
                                                                                                                                                let v11536 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11533 v11535 
                                                                                                                                                let _v11534 = v11536 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v11537 : string = "&*$0"
                                                                                                                                                let v11538 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11533 v11537 
                                                                                                                                                let _v11534 = v11538 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v11539 : string = "&*$0"
                                                                                                                                                let v11540 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11533 v11539 
                                                                                                                                                let _v11534 = v11540 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v11541 : Ref<Str> = v11533 |> unbox<Ref<Str>>
                                                                                                                                                let _v11534 = v11541 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v11544 : Ref<Str> = v11533 |> unbox<Ref<Str>>
                                                                                                                                                let _v11534 = v11544 
                                                                                                                                                #endif
#else
                                                                                                                                                let v11547 : Ref<Str> = v11533 |> unbox<Ref<Str>>
                                                                                                                                                let _v11534 = v11547 
                                                                                                                                                #endif
                                                                                                                                                let v11550 : Ref<Str> = _v11534 
                                                                                                                                                let v11555 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v11556 : string = "String::from($0)"
                                                                                                                                                let v11557 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11550 v11556 
                                                                                                                                                let _v11555 = v11557 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v11558 : string = "String::from($0)"
                                                                                                                                                let v11559 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11550 v11558 
                                                                                                                                                let _v11555 = v11559 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v11560 : string = "String::from($0)"
                                                                                                                                                let v11561 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11550 v11560 
                                                                                                                                                let _v11555 = v11561 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v11562 : std_string_String = v11550 |> unbox<std_string_String>
                                                                                                                                                let _v11555 = v11562 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v11565 : std_string_String = v11550 |> unbox<std_string_String>
                                                                                                                                                let _v11555 = v11565 
                                                                                                                                                #endif
#else
                                                                                                                                                let v11568 : std_string_String = v11550 |> unbox<std_string_String>
                                                                                                                                                let _v11555 = v11568 
                                                                                                                                                #endif
                                                                                                                                                let v11571 : std_string_String = _v11555 
                                                                                                                                                let v11576 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v11577 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v11578 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11571 v11577 
                                                                                                                                                let _v11576 = v11578 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v11579 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v11580 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11571 v11579 
                                                                                                                                                let _v11576 = v11580 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v11581 : string = "std::path::PathBuf::from($0)"
                                                                                                                                                let v11582 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11571 v11581 
                                                                                                                                                let _v11576 = v11582 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v11583 : std_path_PathBuf = v11571 |> std_path_PathBuf 
                                                                                                                                                let _v11576 = v11583 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v11586 : std_path_PathBuf = v11571 |> std_path_PathBuf 
                                                                                                                                                let _v11576 = v11586 
                                                                                                                                                #endif
#else
                                                                                                                                                let v11589 : std_path_PathBuf = v11571 |> std_path_PathBuf 
                                                                                                                                                let _v11576 = v11589 
                                                                                                                                                #endif
                                                                                                                                                let v11592 : std_path_PathBuf = _v11576 
                                                                                                                                                let v11597 : unit = ()
                                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                                let v11598 : string = "Ok($0)"
                                                                                                                                                let v11599 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11592 v11598 
                                                                                                                                                let _v11597 = v11599 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                                let v11600 : string = "Ok($0)"
                                                                                                                                                let v11601 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11592 v11600 
                                                                                                                                                let _v11597 = v11601 
                                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                                let v11602 : string = "Ok($0)"
                                                                                                                                                let v11603 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11592 v11602 
                                                                                                                                                let _v11597 = v11603 
                                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                                let v11604 : Result<std_path_PathBuf, std_io_Error> = v11592 |> Ok
                                                                                                                                                let _v11597 = v11604 
                                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                                let v11605 : Result<std_path_PathBuf, std_io_Error> = v11592 |> Ok
                                                                                                                                                let _v11597 = v11605 
                                                                                                                                                #endif
#else
                                                                                                                                                let v11606 : Result<std_path_PathBuf, std_io_Error> = v11592 |> Ok
                                                                                                                                                let _v11597 = v11606 
                                                                                                                                                #endif
                                                                                                                                                let v11607 : Result<std_path_PathBuf, std_io_Error> = _v11597 
                                                                                                                                                v11607
                                                                                                                                        else
                                                                                                                                            let v11640 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v10159} / path': {v10015} / name: {v10162}"
                                                                                                                                            let v11641 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11642 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v11643 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11640 v11642 
                                                                                                                                            let _v11641 = v11643 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11644 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v11645 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11640 v11644 
                                                                                                                                            let _v11641 = v11645 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11646 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                            let v11647 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11640 v11646 
                                                                                                                                            let _v11641 = v11647 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11648 : std_io_Error = v11640 
                                                                                                                                            let _v11641 = v11648 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11649 : std_io_Error = v11640 
                                                                                                                                            let _v11641 = v11649 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11650 : std_io_Error = v11640 
                                                                                                                                            let _v11641 = v11650 
                                                                                                                                            #endif
                                                                                                                                            let v11651 : std_io_Error = _v11641 
                                                                                                                                            let v11654 : unit = ()
                                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                            let v11655 : string = "Err($0)"
                                                                                                                                            let v11656 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11651 v11655 
                                                                                                                                            let _v11654 = v11656 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                            let v11657 : string = "Err($0)"
                                                                                                                                            let v11658 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11651 v11657 
                                                                                                                                            let _v11654 = v11658 
                                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                            let v11659 : string = "Err($0)"
                                                                                                                                            let v11660 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11651 v11659 
                                                                                                                                            let _v11654 = v11660 
                                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                            let v11661 : Result<std_path_PathBuf, std_io_Error> = v11651 |> Error
                                                                                                                                            let _v11654 = v11661 
                                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                            let v11662 : Result<std_path_PathBuf, std_io_Error> = v11651 |> Error
                                                                                                                                            let _v11654 = v11662 
                                                                                                                                            #endif
#else
                                                                                                                                            let v11663 : Result<std_path_PathBuf, std_io_Error> = v11651 |> Error
                                                                                                                                            let _v11654 = v11663 
                                                                                                                                            #endif
                                                                                                                                            let v11664 : Result<std_path_PathBuf, std_io_Error> = _v11654 
                                                                                                                                            v11664
                                                                                                                                    | _ ->
                                                                                                                                        let v11668 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v10159} / path': {v10015} / name: {v10162}"
                                                                                                                                        let v11669 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v11670 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v11671 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11668 v11670 
                                                                                                                                        let _v11669 = v11671 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v11672 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v11673 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11668 v11672 
                                                                                                                                        let _v11669 = v11673 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v11674 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                        let v11675 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11668 v11674 
                                                                                                                                        let _v11669 = v11675 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v11676 : std_io_Error = v11668 
                                                                                                                                        let _v11669 = v11676 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v11677 : std_io_Error = v11668 
                                                                                                                                        let _v11669 = v11677 
                                                                                                                                        #endif
#else
                                                                                                                                        let v11678 : std_io_Error = v11668 
                                                                                                                                        let _v11669 = v11678 
                                                                                                                                        #endif
                                                                                                                                        let v11679 : std_io_Error = _v11669 
                                                                                                                                        let v11682 : unit = ()
                                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                        let v11683 : string = "Err($0)"
                                                                                                                                        let v11684 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11679 v11683 
                                                                                                                                        let _v11682 = v11684 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                        let v11685 : string = "Err($0)"
                                                                                                                                        let v11686 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11679 v11685 
                                                                                                                                        let _v11682 = v11686 
                                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                        let v11687 : string = "Err($0)"
                                                                                                                                        let v11688 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11679 v11687 
                                                                                                                                        let _v11682 = v11688 
                                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                        let v11689 : Result<std_path_PathBuf, std_io_Error> = v11679 |> Error
                                                                                                                                        let _v11682 = v11689 
                                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                        let v11690 : Result<std_path_PathBuf, std_io_Error> = v11679 |> Error
                                                                                                                                        let _v11682 = v11690 
                                                                                                                                        #endif
#else
                                                                                                                                        let v11691 : Result<std_path_PathBuf, std_io_Error> = v11679 |> Error
                                                                                                                                        let _v11682 = v11691 
                                                                                                                                        #endif
                                                                                                                                        let v11692 : Result<std_path_PathBuf, std_io_Error> = _v11682 
                                                                                                                                        v11692
                                                                                                                            let v11697 : (std_io_Error -> string) = method76()
                                                                                                                            let v11698 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11699 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v11700 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11696, v11697) v11699 
                                                                                                                            let _v11698 = v11700 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11701 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v11702 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11696, v11697) v11701 
                                                                                                                            let _v11698 = v11702 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11703 : string = "$0.map_err(|x| $1(x))"
                                                                                                                            let v11704 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11696, v11697) v11703 
                                                                                                                            let _v11698 = v11704 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11705 : Result<std_path_PathBuf, string> = match v11696 with Ok x -> Ok x | Error x -> Error (v11697 x)
                                                                                                                            let _v11698 = v11705 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11706 : Result<std_path_PathBuf, string> = match v11696 with Ok x -> Ok x | Error x -> Error (v11697 x)
                                                                                                                            let _v11698 = v11706 
                                                                                                                            #endif
#else
                                                                                                                            let v11707 : Result<std_path_PathBuf, string> = match v11696 with Ok x -> Ok x | Error x -> Error (v11697 x)
                                                                                                                            let _v11698 = v11707 
                                                                                                                            #endif
                                                                                                                            let v11708 : Result<std_path_PathBuf, string> = _v11698 
                                                                                                                            let v11711 : (std_path_PathBuf -> US13) = closure47()
                                                                                                                            let v11712 : (string -> US13) = closure48()
                                                                                                                            let v11713 : US13 = match v11708 with Ok x -> v11711 x | Error x -> v11712 x
                                                                                                                            match v11713 with
                                                                                                                            | US13_1(v11816) -> (* Error *)
                                                                                                                                let v11817 : string = $"file_system.read_link / error': {v11816} / error: {v9993} / name: {v9996}"
                                                                                                                                let v11818 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v11819 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v11820 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11817 v11819 
                                                                                                                                let _v11818 = v11820 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v11821 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v11822 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11817 v11821 
                                                                                                                                let _v11818 = v11822 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v11823 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                                let v11824 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11817 v11823 
                                                                                                                                let _v11818 = v11824 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v11825 : std_io_Error = v11817 
                                                                                                                                let _v11818 = v11825 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v11826 : std_io_Error = v11817 
                                                                                                                                let _v11818 = v11826 
                                                                                                                                #endif
#else
                                                                                                                                let v11827 : std_io_Error = v11817 
                                                                                                                                let _v11818 = v11827 
                                                                                                                                #endif
                                                                                                                                let v11828 : std_io_Error = _v11818 
                                                                                                                                let v11831 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v11832 : string = "Err($0)"
                                                                                                                                let v11833 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11828 v11832 
                                                                                                                                let _v11831 = v11833 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v11834 : string = "Err($0)"
                                                                                                                                let v11835 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11828 v11834 
                                                                                                                                let _v11831 = v11835 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v11836 : string = "Err($0)"
                                                                                                                                let v11837 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11828 v11836 
                                                                                                                                let _v11831 = v11837 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v11838 : Result<std_path_PathBuf, std_io_Error> = v11828 |> Error
                                                                                                                                let _v11831 = v11838 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v11839 : Result<std_path_PathBuf, std_io_Error> = v11828 |> Error
                                                                                                                                let _v11831 = v11839 
                                                                                                                                #endif
#else
                                                                                                                                let v11840 : Result<std_path_PathBuf, std_io_Error> = v11828 |> Error
                                                                                                                                let _v11831 = v11840 
                                                                                                                                #endif
                                                                                                                                let v11841 : Result<std_path_PathBuf, std_io_Error> = _v11831 
                                                                                                                                v11841
                                                                                                                            | US13_0(v11714) -> (* Ok *)
                                                                                                                                let v11715 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v11716 : string = "$0.display()"
                                                                                                                                let v11717 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11714 v11716 
                                                                                                                                let _v11715 = v11717 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v11718 : string = "$0.display()"
                                                                                                                                let v11719 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11714 v11718 
                                                                                                                                let _v11715 = v11719 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v11720 : string = "$0.display()"
                                                                                                                                let v11721 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11714 v11720 
                                                                                                                                let _v11715 = v11721 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v11722 : std_path_Display = v11714 |> unbox<std_path_Display>
                                                                                                                                let _v11715 = v11722 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v11725 : std_path_Display = v11714 |> unbox<std_path_Display>
                                                                                                                                let _v11715 = v11725 
                                                                                                                                #endif
#else
                                                                                                                                let v11728 : std_path_Display = v11714 |> unbox<std_path_Display>
                                                                                                                                let _v11715 = v11728 
                                                                                                                                #endif
                                                                                                                                let v11731 : std_path_Display = _v11715 
                                                                                                                                let v11736 : string = v11731 |> string 
                                                                                                                                let v11739 : string = method56(v11736, v9996)
                                                                                                                                let v11740 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v11741 : string = "&*$0"
                                                                                                                                let v11742 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11739 v11741 
                                                                                                                                let _v11740 = v11742 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v11743 : string = "&*$0"
                                                                                                                                let v11744 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11739 v11743 
                                                                                                                                let _v11740 = v11744 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v11745 : string = "&*$0"
                                                                                                                                let v11746 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11739 v11745 
                                                                                                                                let _v11740 = v11746 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v11747 : Ref<Str> = v11739 |> unbox<Ref<Str>>
                                                                                                                                let _v11740 = v11747 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v11750 : Ref<Str> = v11739 |> unbox<Ref<Str>>
                                                                                                                                let _v11740 = v11750 
                                                                                                                                #endif
#else
                                                                                                                                let v11753 : Ref<Str> = v11739 |> unbox<Ref<Str>>
                                                                                                                                let _v11740 = v11753 
                                                                                                                                #endif
                                                                                                                                let v11756 : Ref<Str> = _v11740 
                                                                                                                                let v11761 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v11762 : string = "String::from($0)"
                                                                                                                                let v11763 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11756 v11762 
                                                                                                                                let _v11761 = v11763 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v11764 : string = "String::from($0)"
                                                                                                                                let v11765 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11756 v11764 
                                                                                                                                let _v11761 = v11765 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v11766 : string = "String::from($0)"
                                                                                                                                let v11767 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11756 v11766 
                                                                                                                                let _v11761 = v11767 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v11768 : std_string_String = v11756 |> unbox<std_string_String>
                                                                                                                                let _v11761 = v11768 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v11771 : std_string_String = v11756 |> unbox<std_string_String>
                                                                                                                                let _v11761 = v11771 
                                                                                                                                #endif
#else
                                                                                                                                let v11774 : std_string_String = v11756 |> unbox<std_string_String>
                                                                                                                                let _v11761 = v11774 
                                                                                                                                #endif
                                                                                                                                let v11777 : std_string_String = _v11761 
                                                                                                                                let v11782 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v11783 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v11784 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11777 v11783 
                                                                                                                                let _v11782 = v11784 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v11785 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v11786 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11777 v11785 
                                                                                                                                let _v11782 = v11786 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v11787 : string = "std::path::PathBuf::from($0)"
                                                                                                                                let v11788 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11777 v11787 
                                                                                                                                let _v11782 = v11788 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v11789 : std_path_PathBuf = v11777 |> std_path_PathBuf 
                                                                                                                                let _v11782 = v11789 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v11792 : std_path_PathBuf = v11777 |> std_path_PathBuf 
                                                                                                                                let _v11782 = v11792 
                                                                                                                                #endif
#else
                                                                                                                                let v11795 : std_path_PathBuf = v11777 |> std_path_PathBuf 
                                                                                                                                let _v11782 = v11795 
                                                                                                                                #endif
                                                                                                                                let v11798 : std_path_PathBuf = _v11782 
                                                                                                                                let v11803 : unit = ()
                                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                                let v11804 : string = "Ok($0)"
                                                                                                                                let v11805 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11798 v11804 
                                                                                                                                let _v11803 = v11805 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                                let v11806 : string = "Ok($0)"
                                                                                                                                let v11807 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11798 v11806 
                                                                                                                                let _v11803 = v11807 
                                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                                let v11808 : string = "Ok($0)"
                                                                                                                                let v11809 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11798 v11808 
                                                                                                                                let _v11803 = v11809 
                                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                                let v11810 : Result<std_path_PathBuf, std_io_Error> = v11798 |> Ok
                                                                                                                                let _v11803 = v11810 
                                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                                let v11811 : Result<std_path_PathBuf, std_io_Error> = v11798 |> Ok
                                                                                                                                let _v11803 = v11811 
                                                                                                                                #endif
#else
                                                                                                                                let v11812 : Result<std_path_PathBuf, std_io_Error> = v11798 |> Ok
                                                                                                                                let _v11803 = v11812 
                                                                                                                                #endif
                                                                                                                                let v11813 : Result<std_path_PathBuf, std_io_Error> = _v11803 
                                                                                                                                v11813
                                                                                                                        else
                                                                                                                            let v11846 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9993} / path': {v9849} / name: {v9996}"
                                                                                                                            let v11847 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11848 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v11849 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11846 v11848 
                                                                                                                            let _v11847 = v11849 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11850 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v11851 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11846 v11850 
                                                                                                                            let _v11847 = v11851 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11852 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                            let v11853 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11846 v11852 
                                                                                                                            let _v11847 = v11853 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11854 : std_io_Error = v11846 
                                                                                                                            let _v11847 = v11854 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11855 : std_io_Error = v11846 
                                                                                                                            let _v11847 = v11855 
                                                                                                                            #endif
#else
                                                                                                                            let v11856 : std_io_Error = v11846 
                                                                                                                            let _v11847 = v11856 
                                                                                                                            #endif
                                                                                                                            let v11857 : std_io_Error = _v11847 
                                                                                                                            let v11860 : unit = ()
                                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                            let v11861 : string = "Err($0)"
                                                                                                                            let v11862 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11857 v11861 
                                                                                                                            let _v11860 = v11862 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                            let v11863 : string = "Err($0)"
                                                                                                                            let v11864 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11857 v11863 
                                                                                                                            let _v11860 = v11864 
                                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                            let v11865 : string = "Err($0)"
                                                                                                                            let v11866 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11857 v11865 
                                                                                                                            let _v11860 = v11866 
                                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                            let v11867 : Result<std_path_PathBuf, std_io_Error> = v11857 |> Error
                                                                                                                            let _v11860 = v11867 
                                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                            let v11868 : Result<std_path_PathBuf, std_io_Error> = v11857 |> Error
                                                                                                                            let _v11860 = v11868 
                                                                                                                            #endif
#else
                                                                                                                            let v11869 : Result<std_path_PathBuf, std_io_Error> = v11857 |> Error
                                                                                                                            let _v11860 = v11869 
                                                                                                                            #endif
                                                                                                                            let v11870 : Result<std_path_PathBuf, std_io_Error> = _v11860 
                                                                                                                            v11870
                                                                                                                    | _ ->
                                                                                                                        let v11874 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9993} / path': {v9849} / name: {v9996}"
                                                                                                                        let v11875 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v11876 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v11877 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11874 v11876 
                                                                                                                        let _v11875 = v11877 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v11878 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v11879 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11874 v11878 
                                                                                                                        let _v11875 = v11879 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v11880 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                        let v11881 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v11874 v11880 
                                                                                                                        let _v11875 = v11881 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v11882 : std_io_Error = v11874 
                                                                                                                        let _v11875 = v11882 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v11883 : std_io_Error = v11874 
                                                                                                                        let _v11875 = v11883 
                                                                                                                        #endif
#else
                                                                                                                        let v11884 : std_io_Error = v11874 
                                                                                                                        let _v11875 = v11884 
                                                                                                                        #endif
                                                                                                                        let v11885 : std_io_Error = _v11875 
                                                                                                                        let v11888 : unit = ()
                                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                        let v11889 : string = "Err($0)"
                                                                                                                        let v11890 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11885 v11889 
                                                                                                                        let _v11888 = v11890 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                        let v11891 : string = "Err($0)"
                                                                                                                        let v11892 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11885 v11891 
                                                                                                                        let _v11888 = v11892 
                                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                        let v11893 : string = "Err($0)"
                                                                                                                        let v11894 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v11885 v11893 
                                                                                                                        let _v11888 = v11894 
                                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                        let v11895 : Result<std_path_PathBuf, std_io_Error> = v11885 |> Error
                                                                                                                        let _v11888 = v11895 
                                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                        let v11896 : Result<std_path_PathBuf, std_io_Error> = v11885 |> Error
                                                                                                                        let _v11888 = v11896 
                                                                                                                        #endif
#else
                                                                                                                        let v11897 : Result<std_path_PathBuf, std_io_Error> = v11885 |> Error
                                                                                                                        let _v11888 = v11897 
                                                                                                                        #endif
                                                                                                                        let v11898 : Result<std_path_PathBuf, std_io_Error> = _v11888 
                                                                                                                        v11898
                                                                                                            let v11903 : (std_io_Error -> string) = method76()
                                                                                                            let v11904 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v11905 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v11906 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11902, v11903) v11905 
                                                                                                            let _v11904 = v11906 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v11907 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v11908 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11902, v11903) v11907 
                                                                                                            let _v11904 = v11908 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v11909 : string = "$0.map_err(|x| $1(x))"
                                                                                                            let v11910 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v11902, v11903) v11909 
                                                                                                            let _v11904 = v11910 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v11911 : Result<std_path_PathBuf, string> = match v11902 with Ok x -> Ok x | Error x -> Error (v11903 x)
                                                                                                            let _v11904 = v11911 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v11912 : Result<std_path_PathBuf, string> = match v11902 with Ok x -> Ok x | Error x -> Error (v11903 x)
                                                                                                            let _v11904 = v11912 
                                                                                                            #endif
#else
                                                                                                            let v11913 : Result<std_path_PathBuf, string> = match v11902 with Ok x -> Ok x | Error x -> Error (v11903 x)
                                                                                                            let _v11904 = v11913 
                                                                                                            #endif
                                                                                                            let v11914 : Result<std_path_PathBuf, string> = _v11904 
                                                                                                            let v11917 : (std_path_PathBuf -> US13) = closure47()
                                                                                                            let v11918 : (string -> US13) = closure48()
                                                                                                            let v11919 : US13 = match v11914 with Ok x -> v11917 x | Error x -> v11918 x
                                                                                                            match v11919 with
                                                                                                            | US13_1(v12022) -> (* Error *)
                                                                                                                let v12023 : string = $"file_system.read_link / error': {v12022} / error: {v9827} / name: {v9830}"
                                                                                                                let v12024 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v12025 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v12026 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12023 v12025 
                                                                                                                let _v12024 = v12026 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v12027 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v12028 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12023 v12027 
                                                                                                                let _v12024 = v12028 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v12029 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                                let v12030 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12023 v12029 
                                                                                                                let _v12024 = v12030 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v12031 : std_io_Error = v12023 
                                                                                                                let _v12024 = v12031 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v12032 : std_io_Error = v12023 
                                                                                                                let _v12024 = v12032 
                                                                                                                #endif
#else
                                                                                                                let v12033 : std_io_Error = v12023 
                                                                                                                let _v12024 = v12033 
                                                                                                                #endif
                                                                                                                let v12034 : std_io_Error = _v12024 
                                                                                                                let v12037 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v12038 : string = "Err($0)"
                                                                                                                let v12039 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12034 v12038 
                                                                                                                let _v12037 = v12039 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v12040 : string = "Err($0)"
                                                                                                                let v12041 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12034 v12040 
                                                                                                                let _v12037 = v12041 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v12042 : string = "Err($0)"
                                                                                                                let v12043 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12034 v12042 
                                                                                                                let _v12037 = v12043 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v12044 : Result<std_path_PathBuf, std_io_Error> = v12034 |> Error
                                                                                                                let _v12037 = v12044 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v12045 : Result<std_path_PathBuf, std_io_Error> = v12034 |> Error
                                                                                                                let _v12037 = v12045 
                                                                                                                #endif
#else
                                                                                                                let v12046 : Result<std_path_PathBuf, std_io_Error> = v12034 |> Error
                                                                                                                let _v12037 = v12046 
                                                                                                                #endif
                                                                                                                let v12047 : Result<std_path_PathBuf, std_io_Error> = _v12037 
                                                                                                                v12047
                                                                                                            | US13_0(v11920) -> (* Ok *)
                                                                                                                let v11921 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v11922 : string = "$0.display()"
                                                                                                                let v11923 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11920 v11922 
                                                                                                                let _v11921 = v11923 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v11924 : string = "$0.display()"
                                                                                                                let v11925 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11920 v11924 
                                                                                                                let _v11921 = v11925 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v11926 : string = "$0.display()"
                                                                                                                let v11927 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v11920 v11926 
                                                                                                                let _v11921 = v11927 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v11928 : std_path_Display = v11920 |> unbox<std_path_Display>
                                                                                                                let _v11921 = v11928 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v11931 : std_path_Display = v11920 |> unbox<std_path_Display>
                                                                                                                let _v11921 = v11931 
                                                                                                                #endif
#else
                                                                                                                let v11934 : std_path_Display = v11920 |> unbox<std_path_Display>
                                                                                                                let _v11921 = v11934 
                                                                                                                #endif
                                                                                                                let v11937 : std_path_Display = _v11921 
                                                                                                                let v11942 : string = v11937 |> string 
                                                                                                                let v11945 : string = method56(v11942, v9830)
                                                                                                                let v11946 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v11947 : string = "&*$0"
                                                                                                                let v11948 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11945 v11947 
                                                                                                                let _v11946 = v11948 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v11949 : string = "&*$0"
                                                                                                                let v11950 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11945 v11949 
                                                                                                                let _v11946 = v11950 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v11951 : string = "&*$0"
                                                                                                                let v11952 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v11945 v11951 
                                                                                                                let _v11946 = v11952 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v11953 : Ref<Str> = v11945 |> unbox<Ref<Str>>
                                                                                                                let _v11946 = v11953 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v11956 : Ref<Str> = v11945 |> unbox<Ref<Str>>
                                                                                                                let _v11946 = v11956 
                                                                                                                #endif
#else
                                                                                                                let v11959 : Ref<Str> = v11945 |> unbox<Ref<Str>>
                                                                                                                let _v11946 = v11959 
                                                                                                                #endif
                                                                                                                let v11962 : Ref<Str> = _v11946 
                                                                                                                let v11967 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v11968 : string = "String::from($0)"
                                                                                                                let v11969 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11962 v11968 
                                                                                                                let _v11967 = v11969 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v11970 : string = "String::from($0)"
                                                                                                                let v11971 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11962 v11970 
                                                                                                                let _v11967 = v11971 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v11972 : string = "String::from($0)"
                                                                                                                let v11973 : std_string_String = Fable.Core.RustInterop.emitRustExpr v11962 v11972 
                                                                                                                let _v11967 = v11973 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v11974 : std_string_String = v11962 |> unbox<std_string_String>
                                                                                                                let _v11967 = v11974 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v11977 : std_string_String = v11962 |> unbox<std_string_String>
                                                                                                                let _v11967 = v11977 
                                                                                                                #endif
#else
                                                                                                                let v11980 : std_string_String = v11962 |> unbox<std_string_String>
                                                                                                                let _v11967 = v11980 
                                                                                                                #endif
                                                                                                                let v11983 : std_string_String = _v11967 
                                                                                                                let v11988 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v11989 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v11990 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11983 v11989 
                                                                                                                let _v11988 = v11990 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v11991 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v11992 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11983 v11991 
                                                                                                                let _v11988 = v11992 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v11993 : string = "std::path::PathBuf::from($0)"
                                                                                                                let v11994 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v11983 v11993 
                                                                                                                let _v11988 = v11994 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v11995 : std_path_PathBuf = v11983 |> std_path_PathBuf 
                                                                                                                let _v11988 = v11995 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v11998 : std_path_PathBuf = v11983 |> std_path_PathBuf 
                                                                                                                let _v11988 = v11998 
                                                                                                                #endif
#else
                                                                                                                let v12001 : std_path_PathBuf = v11983 |> std_path_PathBuf 
                                                                                                                let _v11988 = v12001 
                                                                                                                #endif
                                                                                                                let v12004 : std_path_PathBuf = _v11988 
                                                                                                                let v12009 : unit = ()
                                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                                let v12010 : string = "Ok($0)"
                                                                                                                let v12011 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12004 v12010 
                                                                                                                let _v12009 = v12011 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                                let v12012 : string = "Ok($0)"
                                                                                                                let v12013 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12004 v12012 
                                                                                                                let _v12009 = v12013 
                                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                                let v12014 : string = "Ok($0)"
                                                                                                                let v12015 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12004 v12014 
                                                                                                                let _v12009 = v12015 
                                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                                let v12016 : Result<std_path_PathBuf, std_io_Error> = v12004 |> Ok
                                                                                                                let _v12009 = v12016 
                                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                                let v12017 : Result<std_path_PathBuf, std_io_Error> = v12004 |> Ok
                                                                                                                let _v12009 = v12017 
                                                                                                                #endif
#else
                                                                                                                let v12018 : Result<std_path_PathBuf, std_io_Error> = v12004 |> Ok
                                                                                                                let _v12009 = v12018 
                                                                                                                #endif
                                                                                                                let v12019 : Result<std_path_PathBuf, std_io_Error> = _v12009 
                                                                                                                v12019
                                                                                                        else
                                                                                                            let v12052 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9827} / path': {v9683} / name: {v9830}"
                                                                                                            let v12053 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v12054 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v12055 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12052 v12054 
                                                                                                            let _v12053 = v12055 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v12056 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v12057 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12052 v12056 
                                                                                                            let _v12053 = v12057 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v12058 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                            let v12059 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12052 v12058 
                                                                                                            let _v12053 = v12059 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v12060 : std_io_Error = v12052 
                                                                                                            let _v12053 = v12060 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v12061 : std_io_Error = v12052 
                                                                                                            let _v12053 = v12061 
                                                                                                            #endif
#else
                                                                                                            let v12062 : std_io_Error = v12052 
                                                                                                            let _v12053 = v12062 
                                                                                                            #endif
                                                                                                            let v12063 : std_io_Error = _v12053 
                                                                                                            let v12066 : unit = ()
                                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                            let v12067 : string = "Err($0)"
                                                                                                            let v12068 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12063 v12067 
                                                                                                            let _v12066 = v12068 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                            let v12069 : string = "Err($0)"
                                                                                                            let v12070 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12063 v12069 
                                                                                                            let _v12066 = v12070 
                                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                            let v12071 : string = "Err($0)"
                                                                                                            let v12072 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12063 v12071 
                                                                                                            let _v12066 = v12072 
                                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                            let v12073 : Result<std_path_PathBuf, std_io_Error> = v12063 |> Error
                                                                                                            let _v12066 = v12073 
                                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                                            let v12074 : Result<std_path_PathBuf, std_io_Error> = v12063 |> Error
                                                                                                            let _v12066 = v12074 
                                                                                                            #endif
#else
                                                                                                            let v12075 : Result<std_path_PathBuf, std_io_Error> = v12063 |> Error
                                                                                                            let _v12066 = v12075 
                                                                                                            #endif
                                                                                                            let v12076 : Result<std_path_PathBuf, std_io_Error> = _v12066 
                                                                                                            v12076
                                                                                                    | _ ->
                                                                                                        let v12080 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9827} / path': {v9683} / name: {v9830}"
                                                                                                        let v12081 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v12082 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v12083 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12080 v12082 
                                                                                                        let _v12081 = v12083 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v12084 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v12085 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12080 v12084 
                                                                                                        let _v12081 = v12085 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v12086 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                        let v12087 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12080 v12086 
                                                                                                        let _v12081 = v12087 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v12088 : std_io_Error = v12080 
                                                                                                        let _v12081 = v12088 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v12089 : std_io_Error = v12080 
                                                                                                        let _v12081 = v12089 
                                                                                                        #endif
#else
                                                                                                        let v12090 : std_io_Error = v12080 
                                                                                                        let _v12081 = v12090 
                                                                                                        #endif
                                                                                                        let v12091 : std_io_Error = _v12081 
                                                                                                        let v12094 : unit = ()
                                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                        let v12095 : string = "Err($0)"
                                                                                                        let v12096 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12091 v12095 
                                                                                                        let _v12094 = v12096 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                        let v12097 : string = "Err($0)"
                                                                                                        let v12098 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12091 v12097 
                                                                                                        let _v12094 = v12098 
                                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                        let v12099 : string = "Err($0)"
                                                                                                        let v12100 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12091 v12099 
                                                                                                        let _v12094 = v12100 
                                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                        let v12101 : Result<std_path_PathBuf, std_io_Error> = v12091 |> Error
                                                                                                        let _v12094 = v12101 
                                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                                        let v12102 : Result<std_path_PathBuf, std_io_Error> = v12091 |> Error
                                                                                                        let _v12094 = v12102 
                                                                                                        #endif
#else
                                                                                                        let v12103 : Result<std_path_PathBuf, std_io_Error> = v12091 |> Error
                                                                                                        let _v12094 = v12103 
                                                                                                        #endif
                                                                                                        let v12104 : Result<std_path_PathBuf, std_io_Error> = _v12094 
                                                                                                        v12104
                                                                                            let v12109 : (std_io_Error -> string) = method76()
                                                                                            let v12110 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12111 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v12112 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12108, v12109) v12111 
                                                                                            let _v12110 = v12112 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12113 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v12114 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12108, v12109) v12113 
                                                                                            let _v12110 = v12114 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12115 : string = "$0.map_err(|x| $1(x))"
                                                                                            let v12116 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12108, v12109) v12115 
                                                                                            let _v12110 = v12116 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12117 : Result<std_path_PathBuf, string> = match v12108 with Ok x -> Ok x | Error x -> Error (v12109 x)
                                                                                            let _v12110 = v12117 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12118 : Result<std_path_PathBuf, string> = match v12108 with Ok x -> Ok x | Error x -> Error (v12109 x)
                                                                                            let _v12110 = v12118 
                                                                                            #endif
#else
                                                                                            let v12119 : Result<std_path_PathBuf, string> = match v12108 with Ok x -> Ok x | Error x -> Error (v12109 x)
                                                                                            let _v12110 = v12119 
                                                                                            #endif
                                                                                            let v12120 : Result<std_path_PathBuf, string> = _v12110 
                                                                                            let v12123 : (std_path_PathBuf -> US13) = closure47()
                                                                                            let v12124 : (string -> US13) = closure48()
                                                                                            let v12125 : US13 = match v12120 with Ok x -> v12123 x | Error x -> v12124 x
                                                                                            match v12125 with
                                                                                            | US13_1(v12228) -> (* Error *)
                                                                                                let v12229 : string = $"file_system.read_link / error': {v12228} / error: {v9661} / name: {v9664}"
                                                                                                let v12230 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v12231 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v12232 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12229 v12231 
                                                                                                let _v12230 = v12232 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v12233 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v12234 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12229 v12233 
                                                                                                let _v12230 = v12234 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v12235 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                                let v12236 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12229 v12235 
                                                                                                let _v12230 = v12236 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v12237 : std_io_Error = v12229 
                                                                                                let _v12230 = v12237 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v12238 : std_io_Error = v12229 
                                                                                                let _v12230 = v12238 
                                                                                                #endif
#else
                                                                                                let v12239 : std_io_Error = v12229 
                                                                                                let _v12230 = v12239 
                                                                                                #endif
                                                                                                let v12240 : std_io_Error = _v12230 
                                                                                                let v12243 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v12244 : string = "Err($0)"
                                                                                                let v12245 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12240 v12244 
                                                                                                let _v12243 = v12245 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v12246 : string = "Err($0)"
                                                                                                let v12247 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12240 v12246 
                                                                                                let _v12243 = v12247 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v12248 : string = "Err($0)"
                                                                                                let v12249 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12240 v12248 
                                                                                                let _v12243 = v12249 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v12250 : Result<std_path_PathBuf, std_io_Error> = v12240 |> Error
                                                                                                let _v12243 = v12250 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v12251 : Result<std_path_PathBuf, std_io_Error> = v12240 |> Error
                                                                                                let _v12243 = v12251 
                                                                                                #endif
#else
                                                                                                let v12252 : Result<std_path_PathBuf, std_io_Error> = v12240 |> Error
                                                                                                let _v12243 = v12252 
                                                                                                #endif
                                                                                                let v12253 : Result<std_path_PathBuf, std_io_Error> = _v12243 
                                                                                                v12253
                                                                                            | US13_0(v12126) -> (* Ok *)
                                                                                                let v12127 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v12128 : string = "$0.display()"
                                                                                                let v12129 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12126 v12128 
                                                                                                let _v12127 = v12129 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v12130 : string = "$0.display()"
                                                                                                let v12131 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12126 v12130 
                                                                                                let _v12127 = v12131 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v12132 : string = "$0.display()"
                                                                                                let v12133 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12126 v12132 
                                                                                                let _v12127 = v12133 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v12134 : std_path_Display = v12126 |> unbox<std_path_Display>
                                                                                                let _v12127 = v12134 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v12137 : std_path_Display = v12126 |> unbox<std_path_Display>
                                                                                                let _v12127 = v12137 
                                                                                                #endif
#else
                                                                                                let v12140 : std_path_Display = v12126 |> unbox<std_path_Display>
                                                                                                let _v12127 = v12140 
                                                                                                #endif
                                                                                                let v12143 : std_path_Display = _v12127 
                                                                                                let v12148 : string = v12143 |> string 
                                                                                                let v12151 : string = method56(v12148, v9664)
                                                                                                let v12152 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v12153 : string = "&*$0"
                                                                                                let v12154 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12151 v12153 
                                                                                                let _v12152 = v12154 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v12155 : string = "&*$0"
                                                                                                let v12156 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12151 v12155 
                                                                                                let _v12152 = v12156 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v12157 : string = "&*$0"
                                                                                                let v12158 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12151 v12157 
                                                                                                let _v12152 = v12158 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v12159 : Ref<Str> = v12151 |> unbox<Ref<Str>>
                                                                                                let _v12152 = v12159 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v12162 : Ref<Str> = v12151 |> unbox<Ref<Str>>
                                                                                                let _v12152 = v12162 
                                                                                                #endif
#else
                                                                                                let v12165 : Ref<Str> = v12151 |> unbox<Ref<Str>>
                                                                                                let _v12152 = v12165 
                                                                                                #endif
                                                                                                let v12168 : Ref<Str> = _v12152 
                                                                                                let v12173 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v12174 : string = "String::from($0)"
                                                                                                let v12175 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12168 v12174 
                                                                                                let _v12173 = v12175 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v12176 : string = "String::from($0)"
                                                                                                let v12177 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12168 v12176 
                                                                                                let _v12173 = v12177 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v12178 : string = "String::from($0)"
                                                                                                let v12179 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12168 v12178 
                                                                                                let _v12173 = v12179 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v12180 : std_string_String = v12168 |> unbox<std_string_String>
                                                                                                let _v12173 = v12180 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v12183 : std_string_String = v12168 |> unbox<std_string_String>
                                                                                                let _v12173 = v12183 
                                                                                                #endif
#else
                                                                                                let v12186 : std_string_String = v12168 |> unbox<std_string_String>
                                                                                                let _v12173 = v12186 
                                                                                                #endif
                                                                                                let v12189 : std_string_String = _v12173 
                                                                                                let v12194 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v12195 : string = "std::path::PathBuf::from($0)"
                                                                                                let v12196 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12189 v12195 
                                                                                                let _v12194 = v12196 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v12197 : string = "std::path::PathBuf::from($0)"
                                                                                                let v12198 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12189 v12197 
                                                                                                let _v12194 = v12198 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v12199 : string = "std::path::PathBuf::from($0)"
                                                                                                let v12200 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12189 v12199 
                                                                                                let _v12194 = v12200 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v12201 : std_path_PathBuf = v12189 |> std_path_PathBuf 
                                                                                                let _v12194 = v12201 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v12204 : std_path_PathBuf = v12189 |> std_path_PathBuf 
                                                                                                let _v12194 = v12204 
                                                                                                #endif
#else
                                                                                                let v12207 : std_path_PathBuf = v12189 |> std_path_PathBuf 
                                                                                                let _v12194 = v12207 
                                                                                                #endif
                                                                                                let v12210 : std_path_PathBuf = _v12194 
                                                                                                let v12215 : unit = ()
                                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                                let v12216 : string = "Ok($0)"
                                                                                                let v12217 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12210 v12216 
                                                                                                let _v12215 = v12217 
                                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                                let v12218 : string = "Ok($0)"
                                                                                                let v12219 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12210 v12218 
                                                                                                let _v12215 = v12219 
                                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                                let v12220 : string = "Ok($0)"
                                                                                                let v12221 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12210 v12220 
                                                                                                let _v12215 = v12221 
                                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                                let v12222 : Result<std_path_PathBuf, std_io_Error> = v12210 |> Ok
                                                                                                let _v12215 = v12222 
                                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                                let v12223 : Result<std_path_PathBuf, std_io_Error> = v12210 |> Ok
                                                                                                let _v12215 = v12223 
                                                                                                #endif
#else
                                                                                                let v12224 : Result<std_path_PathBuf, std_io_Error> = v12210 |> Ok
                                                                                                let _v12215 = v12224 
                                                                                                #endif
                                                                                                let v12225 : Result<std_path_PathBuf, std_io_Error> = _v12215 
                                                                                                v12225
                                                                                        else
                                                                                            let v12258 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9661} / path': {v9517} / name: {v9664}"
                                                                                            let v12259 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12260 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v12261 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12258 v12260 
                                                                                            let _v12259 = v12261 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12262 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v12263 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12258 v12262 
                                                                                            let _v12259 = v12263 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12264 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                            let v12265 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12258 v12264 
                                                                                            let _v12259 = v12265 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12266 : std_io_Error = v12258 
                                                                                            let _v12259 = v12266 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12267 : std_io_Error = v12258 
                                                                                            let _v12259 = v12267 
                                                                                            #endif
#else
                                                                                            let v12268 : std_io_Error = v12258 
                                                                                            let _v12259 = v12268 
                                                                                            #endif
                                                                                            let v12269 : std_io_Error = _v12259 
                                                                                            let v12272 : unit = ()
                                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                            let v12273 : string = "Err($0)"
                                                                                            let v12274 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12269 v12273 
                                                                                            let _v12272 = v12274 
                                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                            let v12275 : string = "Err($0)"
                                                                                            let v12276 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12269 v12275 
                                                                                            let _v12272 = v12276 
                                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                            let v12277 : string = "Err($0)"
                                                                                            let v12278 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12269 v12277 
                                                                                            let _v12272 = v12278 
                                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                            let v12279 : Result<std_path_PathBuf, std_io_Error> = v12269 |> Error
                                                                                            let _v12272 = v12279 
                                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                                            let v12280 : Result<std_path_PathBuf, std_io_Error> = v12269 |> Error
                                                                                            let _v12272 = v12280 
                                                                                            #endif
#else
                                                                                            let v12281 : Result<std_path_PathBuf, std_io_Error> = v12269 |> Error
                                                                                            let _v12272 = v12281 
                                                                                            #endif
                                                                                            let v12282 : Result<std_path_PathBuf, std_io_Error> = _v12272 
                                                                                            v12282
                                                                                    | _ ->
                                                                                        let v12286 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9661} / path': {v9517} / name: {v9664}"
                                                                                        let v12287 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v12288 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v12289 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12286 v12288 
                                                                                        let _v12287 = v12289 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v12290 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v12291 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12286 v12290 
                                                                                        let _v12287 = v12291 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v12292 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                        let v12293 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12286 v12292 
                                                                                        let _v12287 = v12293 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v12294 : std_io_Error = v12286 
                                                                                        let _v12287 = v12294 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v12295 : std_io_Error = v12286 
                                                                                        let _v12287 = v12295 
                                                                                        #endif
#else
                                                                                        let v12296 : std_io_Error = v12286 
                                                                                        let _v12287 = v12296 
                                                                                        #endif
                                                                                        let v12297 : std_io_Error = _v12287 
                                                                                        let v12300 : unit = ()
                                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                        let v12301 : string = "Err($0)"
                                                                                        let v12302 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12297 v12301 
                                                                                        let _v12300 = v12302 
                                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                        let v12303 : string = "Err($0)"
                                                                                        let v12304 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12297 v12303 
                                                                                        let _v12300 = v12304 
                                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                        let v12305 : string = "Err($0)"
                                                                                        let v12306 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12297 v12305 
                                                                                        let _v12300 = v12306 
                                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                        let v12307 : Result<std_path_PathBuf, std_io_Error> = v12297 |> Error
                                                                                        let _v12300 = v12307 
                                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                                        let v12308 : Result<std_path_PathBuf, std_io_Error> = v12297 |> Error
                                                                                        let _v12300 = v12308 
                                                                                        #endif
#else
                                                                                        let v12309 : Result<std_path_PathBuf, std_io_Error> = v12297 |> Error
                                                                                        let _v12300 = v12309 
                                                                                        #endif
                                                                                        let v12310 : Result<std_path_PathBuf, std_io_Error> = _v12300 
                                                                                        v12310
                                                                            let v12315 : (std_io_Error -> string) = method76()
                                                                            let v12316 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12317 : string = "$0.map_err(|x| $1(x))"
                                                                            let v12318 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12314, v12315) v12317 
                                                                            let _v12316 = v12318 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12319 : string = "$0.map_err(|x| $1(x))"
                                                                            let v12320 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12314, v12315) v12319 
                                                                            let _v12316 = v12320 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12321 : string = "$0.map_err(|x| $1(x))"
                                                                            let v12322 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12314, v12315) v12321 
                                                                            let _v12316 = v12322 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12323 : Result<std_path_PathBuf, string> = match v12314 with Ok x -> Ok x | Error x -> Error (v12315 x)
                                                                            let _v12316 = v12323 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12324 : Result<std_path_PathBuf, string> = match v12314 with Ok x -> Ok x | Error x -> Error (v12315 x)
                                                                            let _v12316 = v12324 
                                                                            #endif
#else
                                                                            let v12325 : Result<std_path_PathBuf, string> = match v12314 with Ok x -> Ok x | Error x -> Error (v12315 x)
                                                                            let _v12316 = v12325 
                                                                            #endif
                                                                            let v12326 : Result<std_path_PathBuf, string> = _v12316 
                                                                            let v12329 : (std_path_PathBuf -> US13) = closure47()
                                                                            let v12330 : (string -> US13) = closure48()
                                                                            let v12331 : US13 = match v12326 with Ok x -> v12329 x | Error x -> v12330 x
                                                                            match v12331 with
                                                                            | US13_1(v12434) -> (* Error *)
                                                                                let v12435 : string = $"file_system.read_link / error': {v12434} / error: {v9495} / name: {v9498}"
                                                                                let v12436 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v12437 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v12438 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12435 v12437 
                                                                                let _v12436 = v12438 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v12439 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v12440 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12435 v12439 
                                                                                let _v12436 = v12440 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v12441 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                                let v12442 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12435 v12441 
                                                                                let _v12436 = v12442 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v12443 : std_io_Error = v12435 
                                                                                let _v12436 = v12443 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v12444 : std_io_Error = v12435 
                                                                                let _v12436 = v12444 
                                                                                #endif
#else
                                                                                let v12445 : std_io_Error = v12435 
                                                                                let _v12436 = v12445 
                                                                                #endif
                                                                                let v12446 : std_io_Error = _v12436 
                                                                                let v12449 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v12450 : string = "Err($0)"
                                                                                let v12451 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12446 v12450 
                                                                                let _v12449 = v12451 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v12452 : string = "Err($0)"
                                                                                let v12453 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12446 v12452 
                                                                                let _v12449 = v12453 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v12454 : string = "Err($0)"
                                                                                let v12455 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12446 v12454 
                                                                                let _v12449 = v12455 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v12456 : Result<std_path_PathBuf, std_io_Error> = v12446 |> Error
                                                                                let _v12449 = v12456 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v12457 : Result<std_path_PathBuf, std_io_Error> = v12446 |> Error
                                                                                let _v12449 = v12457 
                                                                                #endif
#else
                                                                                let v12458 : Result<std_path_PathBuf, std_io_Error> = v12446 |> Error
                                                                                let _v12449 = v12458 
                                                                                #endif
                                                                                let v12459 : Result<std_path_PathBuf, std_io_Error> = _v12449 
                                                                                v12459
                                                                            | US13_0(v12332) -> (* Ok *)
                                                                                let v12333 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v12334 : string = "$0.display()"
                                                                                let v12335 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12332 v12334 
                                                                                let _v12333 = v12335 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v12336 : string = "$0.display()"
                                                                                let v12337 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12332 v12336 
                                                                                let _v12333 = v12337 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v12338 : string = "$0.display()"
                                                                                let v12339 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12332 v12338 
                                                                                let _v12333 = v12339 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v12340 : std_path_Display = v12332 |> unbox<std_path_Display>
                                                                                let _v12333 = v12340 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v12343 : std_path_Display = v12332 |> unbox<std_path_Display>
                                                                                let _v12333 = v12343 
                                                                                #endif
#else
                                                                                let v12346 : std_path_Display = v12332 |> unbox<std_path_Display>
                                                                                let _v12333 = v12346 
                                                                                #endif
                                                                                let v12349 : std_path_Display = _v12333 
                                                                                let v12354 : string = v12349 |> string 
                                                                                let v12357 : string = method56(v12354, v9498)
                                                                                let v12358 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v12359 : string = "&*$0"
                                                                                let v12360 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12357 v12359 
                                                                                let _v12358 = v12360 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v12361 : string = "&*$0"
                                                                                let v12362 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12357 v12361 
                                                                                let _v12358 = v12362 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v12363 : string = "&*$0"
                                                                                let v12364 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12357 v12363 
                                                                                let _v12358 = v12364 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v12365 : Ref<Str> = v12357 |> unbox<Ref<Str>>
                                                                                let _v12358 = v12365 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v12368 : Ref<Str> = v12357 |> unbox<Ref<Str>>
                                                                                let _v12358 = v12368 
                                                                                #endif
#else
                                                                                let v12371 : Ref<Str> = v12357 |> unbox<Ref<Str>>
                                                                                let _v12358 = v12371 
                                                                                #endif
                                                                                let v12374 : Ref<Str> = _v12358 
                                                                                let v12379 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v12380 : string = "String::from($0)"
                                                                                let v12381 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12374 v12380 
                                                                                let _v12379 = v12381 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v12382 : string = "String::from($0)"
                                                                                let v12383 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12374 v12382 
                                                                                let _v12379 = v12383 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v12384 : string = "String::from($0)"
                                                                                let v12385 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12374 v12384 
                                                                                let _v12379 = v12385 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v12386 : std_string_String = v12374 |> unbox<std_string_String>
                                                                                let _v12379 = v12386 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v12389 : std_string_String = v12374 |> unbox<std_string_String>
                                                                                let _v12379 = v12389 
                                                                                #endif
#else
                                                                                let v12392 : std_string_String = v12374 |> unbox<std_string_String>
                                                                                let _v12379 = v12392 
                                                                                #endif
                                                                                let v12395 : std_string_String = _v12379 
                                                                                let v12400 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v12401 : string = "std::path::PathBuf::from($0)"
                                                                                let v12402 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12395 v12401 
                                                                                let _v12400 = v12402 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v12403 : string = "std::path::PathBuf::from($0)"
                                                                                let v12404 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12395 v12403 
                                                                                let _v12400 = v12404 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v12405 : string = "std::path::PathBuf::from($0)"
                                                                                let v12406 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12395 v12405 
                                                                                let _v12400 = v12406 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v12407 : std_path_PathBuf = v12395 |> std_path_PathBuf 
                                                                                let _v12400 = v12407 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v12410 : std_path_PathBuf = v12395 |> std_path_PathBuf 
                                                                                let _v12400 = v12410 
                                                                                #endif
#else
                                                                                let v12413 : std_path_PathBuf = v12395 |> std_path_PathBuf 
                                                                                let _v12400 = v12413 
                                                                                #endif
                                                                                let v12416 : std_path_PathBuf = _v12400 
                                                                                let v12421 : unit = ()
                                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                                let v12422 : string = "Ok($0)"
                                                                                let v12423 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12416 v12422 
                                                                                let _v12421 = v12423 
                                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                                let v12424 : string = "Ok($0)"
                                                                                let v12425 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12416 v12424 
                                                                                let _v12421 = v12425 
                                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                                let v12426 : string = "Ok($0)"
                                                                                let v12427 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12416 v12426 
                                                                                let _v12421 = v12427 
                                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                                let v12428 : Result<std_path_PathBuf, std_io_Error> = v12416 |> Ok
                                                                                let _v12421 = v12428 
                                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                                let v12429 : Result<std_path_PathBuf, std_io_Error> = v12416 |> Ok
                                                                                let _v12421 = v12429 
                                                                                #endif
#else
                                                                                let v12430 : Result<std_path_PathBuf, std_io_Error> = v12416 |> Ok
                                                                                let _v12421 = v12430 
                                                                                #endif
                                                                                let v12431 : Result<std_path_PathBuf, std_io_Error> = _v12421 
                                                                                v12431
                                                                        else
                                                                            let v12464 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9495} / path': {v9351} / name: {v9498}"
                                                                            let v12465 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12466 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v12467 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12464 v12466 
                                                                            let _v12465 = v12467 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12468 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v12469 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12464 v12468 
                                                                            let _v12465 = v12469 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12470 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                            let v12471 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12464 v12470 
                                                                            let _v12465 = v12471 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12472 : std_io_Error = v12464 
                                                                            let _v12465 = v12472 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12473 : std_io_Error = v12464 
                                                                            let _v12465 = v12473 
                                                                            #endif
#else
                                                                            let v12474 : std_io_Error = v12464 
                                                                            let _v12465 = v12474 
                                                                            #endif
                                                                            let v12475 : std_io_Error = _v12465 
                                                                            let v12478 : unit = ()
                                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                            let v12479 : string = "Err($0)"
                                                                            let v12480 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12475 v12479 
                                                                            let _v12478 = v12480 
                                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                                            let v12481 : string = "Err($0)"
                                                                            let v12482 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12475 v12481 
                                                                            let _v12478 = v12482 
                                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                            let v12483 : string = "Err($0)"
                                                                            let v12484 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12475 v12483 
                                                                            let _v12478 = v12484 
                                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                            let v12485 : Result<std_path_PathBuf, std_io_Error> = v12475 |> Error
                                                                            let _v12478 = v12485 
                                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                                            let v12486 : Result<std_path_PathBuf, std_io_Error> = v12475 |> Error
                                                                            let _v12478 = v12486 
                                                                            #endif
#else
                                                                            let v12487 : Result<std_path_PathBuf, std_io_Error> = v12475 |> Error
                                                                            let _v12478 = v12487 
                                                                            #endif
                                                                            let v12488 : Result<std_path_PathBuf, std_io_Error> = _v12478 
                                                                            v12488
                                                                    | _ ->
                                                                        let v12492 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9495} / path': {v9351} / name: {v9498}"
                                                                        let v12493 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v12494 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v12495 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12492 v12494 
                                                                        let _v12493 = v12495 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v12496 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v12497 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12492 v12496 
                                                                        let _v12493 = v12497 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v12498 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                        let v12499 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12492 v12498 
                                                                        let _v12493 = v12499 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v12500 : std_io_Error = v12492 
                                                                        let _v12493 = v12500 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v12501 : std_io_Error = v12492 
                                                                        let _v12493 = v12501 
                                                                        #endif
#else
                                                                        let v12502 : std_io_Error = v12492 
                                                                        let _v12493 = v12502 
                                                                        #endif
                                                                        let v12503 : std_io_Error = _v12493 
                                                                        let v12506 : unit = ()
                                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                        let v12507 : string = "Err($0)"
                                                                        let v12508 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12503 v12507 
                                                                        let _v12506 = v12508 
                                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                                        let v12509 : string = "Err($0)"
                                                                        let v12510 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12503 v12509 
                                                                        let _v12506 = v12510 
                                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                        let v12511 : string = "Err($0)"
                                                                        let v12512 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12503 v12511 
                                                                        let _v12506 = v12512 
                                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                        let v12513 : Result<std_path_PathBuf, std_io_Error> = v12503 |> Error
                                                                        let _v12506 = v12513 
                                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                                        let v12514 : Result<std_path_PathBuf, std_io_Error> = v12503 |> Error
                                                                        let _v12506 = v12514 
                                                                        #endif
#else
                                                                        let v12515 : Result<std_path_PathBuf, std_io_Error> = v12503 |> Error
                                                                        let _v12506 = v12515 
                                                                        #endif
                                                                        let v12516 : Result<std_path_PathBuf, std_io_Error> = _v12506 
                                                                        v12516
                                                            let v12521 : (std_io_Error -> string) = method76()
                                                            let v12522 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12523 : string = "$0.map_err(|x| $1(x))"
                                                            let v12524 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12520, v12521) v12523 
                                                            let _v12522 = v12524 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12525 : string = "$0.map_err(|x| $1(x))"
                                                            let v12526 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12520, v12521) v12525 
                                                            let _v12522 = v12526 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12527 : string = "$0.map_err(|x| $1(x))"
                                                            let v12528 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12520, v12521) v12527 
                                                            let _v12522 = v12528 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12529 : Result<std_path_PathBuf, string> = match v12520 with Ok x -> Ok x | Error x -> Error (v12521 x)
                                                            let _v12522 = v12529 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12530 : Result<std_path_PathBuf, string> = match v12520 with Ok x -> Ok x | Error x -> Error (v12521 x)
                                                            let _v12522 = v12530 
                                                            #endif
#else
                                                            let v12531 : Result<std_path_PathBuf, string> = match v12520 with Ok x -> Ok x | Error x -> Error (v12521 x)
                                                            let _v12522 = v12531 
                                                            #endif
                                                            let v12532 : Result<std_path_PathBuf, string> = _v12522 
                                                            let v12535 : (std_path_PathBuf -> US13) = closure47()
                                                            let v12536 : (string -> US13) = closure48()
                                                            let v12537 : US13 = match v12532 with Ok x -> v12535 x | Error x -> v12536 x
                                                            match v12537 with
                                                            | US13_1(v12640) -> (* Error *)
                                                                let v12641 : string = $"file_system.read_link / error': {v12640} / error: {v9329} / name: {v9332}"
                                                                let v12642 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v12643 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v12644 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12641 v12643 
                                                                let _v12642 = v12644 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v12645 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v12646 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12641 v12645 
                                                                let _v12642 = v12646 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v12647 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                                let v12648 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12641 v12647 
                                                                let _v12642 = v12648 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v12649 : std_io_Error = v12641 
                                                                let _v12642 = v12649 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v12650 : std_io_Error = v12641 
                                                                let _v12642 = v12650 
                                                                #endif
#else
                                                                let v12651 : std_io_Error = v12641 
                                                                let _v12642 = v12651 
                                                                #endif
                                                                let v12652 : std_io_Error = _v12642 
                                                                let v12655 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v12656 : string = "Err($0)"
                                                                let v12657 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12652 v12656 
                                                                let _v12655 = v12657 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v12658 : string = "Err($0)"
                                                                let v12659 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12652 v12658 
                                                                let _v12655 = v12659 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v12660 : string = "Err($0)"
                                                                let v12661 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12652 v12660 
                                                                let _v12655 = v12661 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v12662 : Result<std_path_PathBuf, std_io_Error> = v12652 |> Error
                                                                let _v12655 = v12662 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v12663 : Result<std_path_PathBuf, std_io_Error> = v12652 |> Error
                                                                let _v12655 = v12663 
                                                                #endif
#else
                                                                let v12664 : Result<std_path_PathBuf, std_io_Error> = v12652 |> Error
                                                                let _v12655 = v12664 
                                                                #endif
                                                                let v12665 : Result<std_path_PathBuf, std_io_Error> = _v12655 
                                                                v12665
                                                            | US13_0(v12538) -> (* Ok *)
                                                                let v12539 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v12540 : string = "$0.display()"
                                                                let v12541 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12538 v12540 
                                                                let _v12539 = v12541 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v12542 : string = "$0.display()"
                                                                let v12543 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12538 v12542 
                                                                let _v12539 = v12543 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v12544 : string = "$0.display()"
                                                                let v12545 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12538 v12544 
                                                                let _v12539 = v12545 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v12546 : std_path_Display = v12538 |> unbox<std_path_Display>
                                                                let _v12539 = v12546 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v12549 : std_path_Display = v12538 |> unbox<std_path_Display>
                                                                let _v12539 = v12549 
                                                                #endif
#else
                                                                let v12552 : std_path_Display = v12538 |> unbox<std_path_Display>
                                                                let _v12539 = v12552 
                                                                #endif
                                                                let v12555 : std_path_Display = _v12539 
                                                                let v12560 : string = v12555 |> string 
                                                                let v12563 : string = method56(v12560, v9332)
                                                                let v12564 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v12565 : string = "&*$0"
                                                                let v12566 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12563 v12565 
                                                                let _v12564 = v12566 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v12567 : string = "&*$0"
                                                                let v12568 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12563 v12567 
                                                                let _v12564 = v12568 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v12569 : string = "&*$0"
                                                                let v12570 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12563 v12569 
                                                                let _v12564 = v12570 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v12571 : Ref<Str> = v12563 |> unbox<Ref<Str>>
                                                                let _v12564 = v12571 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v12574 : Ref<Str> = v12563 |> unbox<Ref<Str>>
                                                                let _v12564 = v12574 
                                                                #endif
#else
                                                                let v12577 : Ref<Str> = v12563 |> unbox<Ref<Str>>
                                                                let _v12564 = v12577 
                                                                #endif
                                                                let v12580 : Ref<Str> = _v12564 
                                                                let v12585 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v12586 : string = "String::from($0)"
                                                                let v12587 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12580 v12586 
                                                                let _v12585 = v12587 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v12588 : string = "String::from($0)"
                                                                let v12589 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12580 v12588 
                                                                let _v12585 = v12589 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v12590 : string = "String::from($0)"
                                                                let v12591 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12580 v12590 
                                                                let _v12585 = v12591 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v12592 : std_string_String = v12580 |> unbox<std_string_String>
                                                                let _v12585 = v12592 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v12595 : std_string_String = v12580 |> unbox<std_string_String>
                                                                let _v12585 = v12595 
                                                                #endif
#else
                                                                let v12598 : std_string_String = v12580 |> unbox<std_string_String>
                                                                let _v12585 = v12598 
                                                                #endif
                                                                let v12601 : std_string_String = _v12585 
                                                                let v12606 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v12607 : string = "std::path::PathBuf::from($0)"
                                                                let v12608 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12601 v12607 
                                                                let _v12606 = v12608 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v12609 : string = "std::path::PathBuf::from($0)"
                                                                let v12610 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12601 v12609 
                                                                let _v12606 = v12610 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v12611 : string = "std::path::PathBuf::from($0)"
                                                                let v12612 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12601 v12611 
                                                                let _v12606 = v12612 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v12613 : std_path_PathBuf = v12601 |> std_path_PathBuf 
                                                                let _v12606 = v12613 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v12616 : std_path_PathBuf = v12601 |> std_path_PathBuf 
                                                                let _v12606 = v12616 
                                                                #endif
#else
                                                                let v12619 : std_path_PathBuf = v12601 |> std_path_PathBuf 
                                                                let _v12606 = v12619 
                                                                #endif
                                                                let v12622 : std_path_PathBuf = _v12606 
                                                                let v12627 : unit = ()
                                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                                let v12628 : string = "Ok($0)"
                                                                let v12629 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12622 v12628 
                                                                let _v12627 = v12629 
                                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                                let v12630 : string = "Ok($0)"
                                                                let v12631 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12622 v12630 
                                                                let _v12627 = v12631 
                                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                                let v12632 : string = "Ok($0)"
                                                                let v12633 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12622 v12632 
                                                                let _v12627 = v12633 
                                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                                let v12634 : Result<std_path_PathBuf, std_io_Error> = v12622 |> Ok
                                                                let _v12627 = v12634 
                                                                #endif
#if FABLE_COMPILER_PYTHON
                                                                let v12635 : Result<std_path_PathBuf, std_io_Error> = v12622 |> Ok
                                                                let _v12627 = v12635 
                                                                #endif
#else
                                                                let v12636 : Result<std_path_PathBuf, std_io_Error> = v12622 |> Ok
                                                                let _v12627 = v12636 
                                                                #endif
                                                                let v12637 : Result<std_path_PathBuf, std_io_Error> = _v12627 
                                                                v12637
                                                        else
                                                            let v12670 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9329} / path': {v9185} / name: {v9332}"
                                                            let v12671 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12672 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v12673 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12670 v12672 
                                                            let _v12671 = v12673 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12674 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v12675 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12670 v12674 
                                                            let _v12671 = v12675 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12676 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                            let v12677 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12670 v12676 
                                                            let _v12671 = v12677 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12678 : std_io_Error = v12670 
                                                            let _v12671 = v12678 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12679 : std_io_Error = v12670 
                                                            let _v12671 = v12679 
                                                            #endif
#else
                                                            let v12680 : std_io_Error = v12670 
                                                            let _v12671 = v12680 
                                                            #endif
                                                            let v12681 : std_io_Error = _v12671 
                                                            let v12684 : unit = ()
                                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                            let v12685 : string = "Err($0)"
                                                            let v12686 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12681 v12685 
                                                            let _v12684 = v12686 
                                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                                            let v12687 : string = "Err($0)"
                                                            let v12688 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12681 v12687 
                                                            let _v12684 = v12688 
                                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                            let v12689 : string = "Err($0)"
                                                            let v12690 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12681 v12689 
                                                            let _v12684 = v12690 
                                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                            let v12691 : Result<std_path_PathBuf, std_io_Error> = v12681 |> Error
                                                            let _v12684 = v12691 
                                                            #endif
#if FABLE_COMPILER_PYTHON
                                                            let v12692 : Result<std_path_PathBuf, std_io_Error> = v12681 |> Error
                                                            let _v12684 = v12692 
                                                            #endif
#else
                                                            let v12693 : Result<std_path_PathBuf, std_io_Error> = v12681 |> Error
                                                            let _v12684 = v12693 
                                                            #endif
                                                            let v12694 : Result<std_path_PathBuf, std_io_Error> = _v12684 
                                                            v12694
                                                    | _ ->
                                                        let v12698 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9329} / path': {v9185} / name: {v9332}"
                                                        let v12699 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v12700 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v12701 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12698 v12700 
                                                        let _v12699 = v12701 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v12702 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v12703 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12698 v12702 
                                                        let _v12699 = v12703 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v12704 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                        let v12705 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12698 v12704 
                                                        let _v12699 = v12705 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v12706 : std_io_Error = v12698 
                                                        let _v12699 = v12706 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v12707 : std_io_Error = v12698 
                                                        let _v12699 = v12707 
                                                        #endif
#else
                                                        let v12708 : std_io_Error = v12698 
                                                        let _v12699 = v12708 
                                                        #endif
                                                        let v12709 : std_io_Error = _v12699 
                                                        let v12712 : unit = ()
                                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                        let v12713 : string = "Err($0)"
                                                        let v12714 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12709 v12713 
                                                        let _v12712 = v12714 
                                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                                        let v12715 : string = "Err($0)"
                                                        let v12716 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12709 v12715 
                                                        let _v12712 = v12716 
                                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                        let v12717 : string = "Err($0)"
                                                        let v12718 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12709 v12717 
                                                        let _v12712 = v12718 
                                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                        let v12719 : Result<std_path_PathBuf, std_io_Error> = v12709 |> Error
                                                        let _v12712 = v12719 
                                                        #endif
#if FABLE_COMPILER_PYTHON
                                                        let v12720 : Result<std_path_PathBuf, std_io_Error> = v12709 |> Error
                                                        let _v12712 = v12720 
                                                        #endif
#else
                                                        let v12721 : Result<std_path_PathBuf, std_io_Error> = v12709 |> Error
                                                        let _v12712 = v12721 
                                                        #endif
                                                        let v12722 : Result<std_path_PathBuf, std_io_Error> = _v12712 
                                                        v12722
                                            let v12727 : (std_io_Error -> string) = method76()
                                            let v12728 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12729 : string = "$0.map_err(|x| $1(x))"
                                            let v12730 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12726, v12727) v12729 
                                            let _v12728 = v12730 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12731 : string = "$0.map_err(|x| $1(x))"
                                            let v12732 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12726, v12727) v12731 
                                            let _v12728 = v12732 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12733 : string = "$0.map_err(|x| $1(x))"
                                            let v12734 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12726, v12727) v12733 
                                            let _v12728 = v12734 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12735 : Result<std_path_PathBuf, string> = match v12726 with Ok x -> Ok x | Error x -> Error (v12727 x)
                                            let _v12728 = v12735 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12736 : Result<std_path_PathBuf, string> = match v12726 with Ok x -> Ok x | Error x -> Error (v12727 x)
                                            let _v12728 = v12736 
                                            #endif
#else
                                            let v12737 : Result<std_path_PathBuf, string> = match v12726 with Ok x -> Ok x | Error x -> Error (v12727 x)
                                            let _v12728 = v12737 
                                            #endif
                                            let v12738 : Result<std_path_PathBuf, string> = _v12728 
                                            let v12741 : (std_path_PathBuf -> US13) = closure47()
                                            let v12742 : (string -> US13) = closure48()
                                            let v12743 : US13 = match v12738 with Ok x -> v12741 x | Error x -> v12742 x
                                            match v12743 with
                                            | US13_1(v12846) -> (* Error *)
                                                let v12847 : string = $"file_system.read_link / error': {v12846} / error: {v9163} / name: {v9166}"
                                                let v12848 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v12849 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v12850 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12847 v12849 
                                                let _v12848 = v12850 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v12851 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v12852 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12847 v12851 
                                                let _v12848 = v12852 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v12853 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                                let v12854 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12847 v12853 
                                                let _v12848 = v12854 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v12855 : std_io_Error = v12847 
                                                let _v12848 = v12855 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v12856 : std_io_Error = v12847 
                                                let _v12848 = v12856 
                                                #endif
#else
                                                let v12857 : std_io_Error = v12847 
                                                let _v12848 = v12857 
                                                #endif
                                                let v12858 : std_io_Error = _v12848 
                                                let v12861 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v12862 : string = "Err($0)"
                                                let v12863 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12858 v12862 
                                                let _v12861 = v12863 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v12864 : string = "Err($0)"
                                                let v12865 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12858 v12864 
                                                let _v12861 = v12865 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v12866 : string = "Err($0)"
                                                let v12867 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12858 v12866 
                                                let _v12861 = v12867 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v12868 : Result<std_path_PathBuf, std_io_Error> = v12858 |> Error
                                                let _v12861 = v12868 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v12869 : Result<std_path_PathBuf, std_io_Error> = v12858 |> Error
                                                let _v12861 = v12869 
                                                #endif
#else
                                                let v12870 : Result<std_path_PathBuf, std_io_Error> = v12858 |> Error
                                                let _v12861 = v12870 
                                                #endif
                                                let v12871 : Result<std_path_PathBuf, std_io_Error> = _v12861 
                                                v12871
                                            | US13_0(v12744) -> (* Ok *)
                                                let v12745 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v12746 : string = "$0.display()"
                                                let v12747 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12744 v12746 
                                                let _v12745 = v12747 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v12748 : string = "$0.display()"
                                                let v12749 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12744 v12748 
                                                let _v12745 = v12749 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v12750 : string = "$0.display()"
                                                let v12751 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12744 v12750 
                                                let _v12745 = v12751 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v12752 : std_path_Display = v12744 |> unbox<std_path_Display>
                                                let _v12745 = v12752 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v12755 : std_path_Display = v12744 |> unbox<std_path_Display>
                                                let _v12745 = v12755 
                                                #endif
#else
                                                let v12758 : std_path_Display = v12744 |> unbox<std_path_Display>
                                                let _v12745 = v12758 
                                                #endif
                                                let v12761 : std_path_Display = _v12745 
                                                let v12766 : string = v12761 |> string 
                                                let v12769 : string = method56(v12766, v9166)
                                                let v12770 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v12771 : string = "&*$0"
                                                let v12772 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12769 v12771 
                                                let _v12770 = v12772 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v12773 : string = "&*$0"
                                                let v12774 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12769 v12773 
                                                let _v12770 = v12774 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v12775 : string = "&*$0"
                                                let v12776 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12769 v12775 
                                                let _v12770 = v12776 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v12777 : Ref<Str> = v12769 |> unbox<Ref<Str>>
                                                let _v12770 = v12777 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v12780 : Ref<Str> = v12769 |> unbox<Ref<Str>>
                                                let _v12770 = v12780 
                                                #endif
#else
                                                let v12783 : Ref<Str> = v12769 |> unbox<Ref<Str>>
                                                let _v12770 = v12783 
                                                #endif
                                                let v12786 : Ref<Str> = _v12770 
                                                let v12791 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v12792 : string = "String::from($0)"
                                                let v12793 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12786 v12792 
                                                let _v12791 = v12793 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v12794 : string = "String::from($0)"
                                                let v12795 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12786 v12794 
                                                let _v12791 = v12795 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v12796 : string = "String::from($0)"
                                                let v12797 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12786 v12796 
                                                let _v12791 = v12797 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v12798 : std_string_String = v12786 |> unbox<std_string_String>
                                                let _v12791 = v12798 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v12801 : std_string_String = v12786 |> unbox<std_string_String>
                                                let _v12791 = v12801 
                                                #endif
#else
                                                let v12804 : std_string_String = v12786 |> unbox<std_string_String>
                                                let _v12791 = v12804 
                                                #endif
                                                let v12807 : std_string_String = _v12791 
                                                let v12812 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v12813 : string = "std::path::PathBuf::from($0)"
                                                let v12814 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12807 v12813 
                                                let _v12812 = v12814 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v12815 : string = "std::path::PathBuf::from($0)"
                                                let v12816 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12807 v12815 
                                                let _v12812 = v12816 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v12817 : string = "std::path::PathBuf::from($0)"
                                                let v12818 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v12807 v12817 
                                                let _v12812 = v12818 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v12819 : std_path_PathBuf = v12807 |> std_path_PathBuf 
                                                let _v12812 = v12819 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v12822 : std_path_PathBuf = v12807 |> std_path_PathBuf 
                                                let _v12812 = v12822 
                                                #endif
#else
                                                let v12825 : std_path_PathBuf = v12807 |> std_path_PathBuf 
                                                let _v12812 = v12825 
                                                #endif
                                                let v12828 : std_path_PathBuf = _v12812 
                                                let v12833 : unit = ()
                                                
#if FABLE_COMPILER || WASM || CONTRACT
                                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                                let v12834 : string = "Ok($0)"
                                                let v12835 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12828 v12834 
                                                let _v12833 = v12835 
                                                #endif
#if FABLE_COMPILER_RUST && WASM
                                                let v12836 : string = "Ok($0)"
                                                let v12837 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12828 v12836 
                                                let _v12833 = v12837 
                                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                                let v12838 : string = "Ok($0)"
                                                let v12839 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12828 v12838 
                                                let _v12833 = v12839 
                                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                                let v12840 : Result<std_path_PathBuf, std_io_Error> = v12828 |> Ok
                                                let _v12833 = v12840 
                                                #endif
#if FABLE_COMPILER_PYTHON
                                                let v12841 : Result<std_path_PathBuf, std_io_Error> = v12828 |> Ok
                                                let _v12833 = v12841 
                                                #endif
#else
                                                let v12842 : Result<std_path_PathBuf, std_io_Error> = v12828 |> Ok
                                                let _v12833 = v12842 
                                                #endif
                                                let v12843 : Result<std_path_PathBuf, std_io_Error> = _v12833 
                                                v12843
                                        else
                                            let v12876 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9163} / path': {v9018} / name: {v9166}"
                                            let v12877 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12878 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v12879 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12876 v12878 
                                            let _v12877 = v12879 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12880 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v12881 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12876 v12880 
                                            let _v12877 = v12881 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12882 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                            let v12883 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12876 v12882 
                                            let _v12877 = v12883 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12884 : std_io_Error = v12876 
                                            let _v12877 = v12884 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12885 : std_io_Error = v12876 
                                            let _v12877 = v12885 
                                            #endif
#else
                                            let v12886 : std_io_Error = v12876 
                                            let _v12877 = v12886 
                                            #endif
                                            let v12887 : std_io_Error = _v12877 
                                            let v12890 : unit = ()
                                            
#if FABLE_COMPILER || WASM || CONTRACT
                                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                            let v12891 : string = "Err($0)"
                                            let v12892 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12887 v12891 
                                            let _v12890 = v12892 
                                            #endif
#if FABLE_COMPILER_RUST && WASM
                                            let v12893 : string = "Err($0)"
                                            let v12894 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12887 v12893 
                                            let _v12890 = v12894 
                                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                            let v12895 : string = "Err($0)"
                                            let v12896 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12887 v12895 
                                            let _v12890 = v12896 
                                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                                            let v12897 : Result<std_path_PathBuf, std_io_Error> = v12887 |> Error
                                            let _v12890 = v12897 
                                            #endif
#if FABLE_COMPILER_PYTHON
                                            let v12898 : Result<std_path_PathBuf, std_io_Error> = v12887 |> Error
                                            let _v12890 = v12898 
                                            #endif
#else
                                            let v12899 : Result<std_path_PathBuf, std_io_Error> = v12887 |> Error
                                            let _v12890 = v12899 
                                            #endif
                                            let v12900 : Result<std_path_PathBuf, std_io_Error> = _v12890 
                                            v12900
                                    | _ ->
                                        let v12904 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v9163} / path': {v9018} / name: {v9166}"
                                        let v12905 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v12906 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v12907 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12904 v12906 
                                        let _v12905 = v12907 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v12908 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v12909 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12904 v12908 
                                        let _v12905 = v12909 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v12910 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                        let v12911 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v12904 v12910 
                                        let _v12905 = v12911 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v12912 : std_io_Error = v12904 
                                        let _v12905 = v12912 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v12913 : std_io_Error = v12904 
                                        let _v12905 = v12913 
                                        #endif
#else
                                        let v12914 : std_io_Error = v12904 
                                        let _v12905 = v12914 
                                        #endif
                                        let v12915 : std_io_Error = _v12905 
                                        let v12918 : unit = ()
                                        
#if FABLE_COMPILER || WASM || CONTRACT
                                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                        let v12919 : string = "Err($0)"
                                        let v12920 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12915 v12919 
                                        let _v12918 = v12920 
                                        #endif
#if FABLE_COMPILER_RUST && WASM
                                        let v12921 : string = "Err($0)"
                                        let v12922 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12915 v12921 
                                        let _v12918 = v12922 
                                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                        let v12923 : string = "Err($0)"
                                        let v12924 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v12915 v12923 
                                        let _v12918 = v12924 
                                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                                        let v12925 : Result<std_path_PathBuf, std_io_Error> = v12915 |> Error
                                        let _v12918 = v12925 
                                        #endif
#if FABLE_COMPILER_PYTHON
                                        let v12926 : Result<std_path_PathBuf, std_io_Error> = v12915 |> Error
                                        let _v12918 = v12926 
                                        #endif
#else
                                        let v12927 : Result<std_path_PathBuf, std_io_Error> = v12915 |> Error
                                        let _v12918 = v12927 
                                        #endif
                                        let v12928 : Result<std_path_PathBuf, std_io_Error> = _v12918 
                                        v12928
                            let v12933 : (std_io_Error -> string) = method76()
                            let v12934 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v12935 : string = "$0.map_err(|x| $1(x))"
                            let v12936 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12932, v12933) v12935 
                            let _v12934 = v12936 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v12937 : string = "$0.map_err(|x| $1(x))"
                            let v12938 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12932, v12933) v12937 
                            let _v12934 = v12938 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v12939 : string = "$0.map_err(|x| $1(x))"
                            let v12940 : Result<std_path_PathBuf, string> = Fable.Core.RustInterop.emitRustExpr struct (v12932, v12933) v12939 
                            let _v12934 = v12940 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v12941 : Result<std_path_PathBuf, string> = match v12932 with Ok x -> Ok x | Error x -> Error (v12933 x)
                            let _v12934 = v12941 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v12942 : Result<std_path_PathBuf, string> = match v12932 with Ok x -> Ok x | Error x -> Error (v12933 x)
                            let _v12934 = v12942 
                            #endif
#else
                            let v12943 : Result<std_path_PathBuf, string> = match v12932 with Ok x -> Ok x | Error x -> Error (v12933 x)
                            let _v12934 = v12943 
                            #endif
                            let v12944 : Result<std_path_PathBuf, string> = _v12934 
                            let v12947 : (std_path_PathBuf -> US13) = closure47()
                            let v12948 : (string -> US13) = closure48()
                            let v12949 : US13 = match v12944 with Ok x -> v12947 x | Error x -> v12948 x
                            match v12949 with
                            | US13_1(v13052) -> (* Error *)
                                let v13053 : string = $"file_system.read_link / error': {v13052} / error: {v8996} / name: {v8999}"
                                let v13054 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v13055 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v13056 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13053 v13055 
                                let _v13054 = v13056 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v13057 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v13058 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13053 v13057 
                                let _v13054 = v13058 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v13059 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                                let v13060 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13053 v13059 
                                let _v13054 = v13060 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v13061 : std_io_Error = v13053 
                                let _v13054 = v13061 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v13062 : std_io_Error = v13053 
                                let _v13054 = v13062 
                                #endif
#else
                                let v13063 : std_io_Error = v13053 
                                let _v13054 = v13063 
                                #endif
                                let v13064 : std_io_Error = _v13054 
                                let v13067 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v13068 : string = "Err($0)"
                                let v13069 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13064 v13068 
                                let _v13067 = v13069 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v13070 : string = "Err($0)"
                                let v13071 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13064 v13070 
                                let _v13067 = v13071 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v13072 : string = "Err($0)"
                                let v13073 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13064 v13072 
                                let _v13067 = v13073 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v13074 : Result<std_path_PathBuf, std_io_Error> = v13064 |> Error
                                let _v13067 = v13074 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v13075 : Result<std_path_PathBuf, std_io_Error> = v13064 |> Error
                                let _v13067 = v13075 
                                #endif
#else
                                let v13076 : Result<std_path_PathBuf, std_io_Error> = v13064 |> Error
                                let _v13067 = v13076 
                                #endif
                                let v13077 : Result<std_path_PathBuf, std_io_Error> = _v13067 
                                v13077
                            | US13_0(v12950) -> (* Ok *)
                                let v12951 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v12952 : string = "$0.display()"
                                let v12953 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12950 v12952 
                                let _v12951 = v12953 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v12954 : string = "$0.display()"
                                let v12955 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12950 v12954 
                                let _v12951 = v12955 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v12956 : string = "$0.display()"
                                let v12957 : std_path_Display = Fable.Core.RustInterop.emitRustExpr v12950 v12956 
                                let _v12951 = v12957 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v12958 : std_path_Display = v12950 |> unbox<std_path_Display>
                                let _v12951 = v12958 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v12961 : std_path_Display = v12950 |> unbox<std_path_Display>
                                let _v12951 = v12961 
                                #endif
#else
                                let v12964 : std_path_Display = v12950 |> unbox<std_path_Display>
                                let _v12951 = v12964 
                                #endif
                                let v12967 : std_path_Display = _v12951 
                                let v12972 : string = v12967 |> string 
                                let v12975 : string = method56(v12972, v8999)
                                let v12976 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v12977 : string = "&*$0"
                                let v12978 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12975 v12977 
                                let _v12976 = v12978 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v12979 : string = "&*$0"
                                let v12980 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12975 v12979 
                                let _v12976 = v12980 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v12981 : string = "&*$0"
                                let v12982 : Ref<Str> = Fable.Core.RustInterop.emitRustExpr v12975 v12981 
                                let _v12976 = v12982 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v12983 : Ref<Str> = v12975 |> unbox<Ref<Str>>
                                let _v12976 = v12983 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v12986 : Ref<Str> = v12975 |> unbox<Ref<Str>>
                                let _v12976 = v12986 
                                #endif
#else
                                let v12989 : Ref<Str> = v12975 |> unbox<Ref<Str>>
                                let _v12976 = v12989 
                                #endif
                                let v12992 : Ref<Str> = _v12976 
                                let v12997 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v12998 : string = "String::from($0)"
                                let v12999 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12992 v12998 
                                let _v12997 = v12999 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v13000 : string = "String::from($0)"
                                let v13001 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12992 v13000 
                                let _v12997 = v13001 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v13002 : string = "String::from($0)"
                                let v13003 : std_string_String = Fable.Core.RustInterop.emitRustExpr v12992 v13002 
                                let _v12997 = v13003 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v13004 : std_string_String = v12992 |> unbox<std_string_String>
                                let _v12997 = v13004 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v13007 : std_string_String = v12992 |> unbox<std_string_String>
                                let _v12997 = v13007 
                                #endif
#else
                                let v13010 : std_string_String = v12992 |> unbox<std_string_String>
                                let _v12997 = v13010 
                                #endif
                                let v13013 : std_string_String = _v12997 
                                let v13018 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v13019 : string = "std::path::PathBuf::from($0)"
                                let v13020 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v13013 v13019 
                                let _v13018 = v13020 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v13021 : string = "std::path::PathBuf::from($0)"
                                let v13022 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v13013 v13021 
                                let _v13018 = v13022 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v13023 : string = "std::path::PathBuf::from($0)"
                                let v13024 : std_path_PathBuf = Fable.Core.RustInterop.emitRustExpr v13013 v13023 
                                let _v13018 = v13024 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v13025 : std_path_PathBuf = v13013 |> std_path_PathBuf 
                                let _v13018 = v13025 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v13028 : std_path_PathBuf = v13013 |> std_path_PathBuf 
                                let _v13018 = v13028 
                                #endif
#else
                                let v13031 : std_path_PathBuf = v13013 |> std_path_PathBuf 
                                let _v13018 = v13031 
                                #endif
                                let v13034 : std_path_PathBuf = _v13018 
                                let v13039 : unit = ()
                                
#if FABLE_COMPILER || WASM || CONTRACT
                                
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                                let v13040 : string = "Ok($0)"
                                let v13041 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13034 v13040 
                                let _v13039 = v13041 
                                #endif
#if FABLE_COMPILER_RUST && WASM
                                let v13042 : string = "Ok($0)"
                                let v13043 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13034 v13042 
                                let _v13039 = v13043 
                                #endif
#if FABLE_COMPILER_RUST && CONTRACT
                                let v13044 : string = "Ok($0)"
                                let v13045 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13034 v13044 
                                let _v13039 = v13045 
                                #endif
#if FABLE_COMPILER_TYPESCRIPT
                                let v13046 : Result<std_path_PathBuf, std_io_Error> = v13034 |> Ok
                                let _v13039 = v13046 
                                #endif
#if FABLE_COMPILER_PYTHON
                                let v13047 : Result<std_path_PathBuf, std_io_Error> = v13034 |> Ok
                                let _v13039 = v13047 
                                #endif
#else
                                let v13048 : Result<std_path_PathBuf, std_io_Error> = v13034 |> Ok
                                let _v13039 = v13048 
                                #endif
                                let v13049 : Result<std_path_PathBuf, std_io_Error> = _v13039 
                                v13049
                        else
                            let v13082 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v8996} / path': {v1} / name: {v8999}"
                            let v13083 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v13084 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v13085 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13082 v13084 
                            let _v13083 = v13085 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v13086 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v13087 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13082 v13086 
                            let _v13083 = v13087 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v13088 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                            let v13089 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13082 v13088 
                            let _v13083 = v13089 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v13090 : std_io_Error = v13082 
                            let _v13083 = v13090 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v13091 : std_io_Error = v13082 
                            let _v13083 = v13091 
                            #endif
#else
                            let v13092 : std_io_Error = v13082 
                            let _v13083 = v13092 
                            #endif
                            let v13093 : std_io_Error = _v13083 
                            let v13096 : unit = ()
                            
#if FABLE_COMPILER || WASM || CONTRACT
                            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                            let v13097 : string = "Err($0)"
                            let v13098 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13093 v13097 
                            let _v13096 = v13098 
                            #endif
#if FABLE_COMPILER_RUST && WASM
                            let v13099 : string = "Err($0)"
                            let v13100 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13093 v13099 
                            let _v13096 = v13100 
                            #endif
#if FABLE_COMPILER_RUST && CONTRACT
                            let v13101 : string = "Err($0)"
                            let v13102 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13093 v13101 
                            let _v13096 = v13102 
                            #endif
#if FABLE_COMPILER_TYPESCRIPT
                            let v13103 : Result<std_path_PathBuf, std_io_Error> = v13093 |> Error
                            let _v13096 = v13103 
                            #endif
#if FABLE_COMPILER_PYTHON
                            let v13104 : Result<std_path_PathBuf, std_io_Error> = v13093 |> Error
                            let _v13096 = v13104 
                            #endif
#else
                            let v13105 : Result<std_path_PathBuf, std_io_Error> = v13093 |> Error
                            let _v13096 = v13105 
                            #endif
                            let v13106 : Result<std_path_PathBuf, std_io_Error> = _v13096 
                            v13106
                    | _ ->
                        let v13110 : string = $"file_system.read_link / run / The file or directory is not a reparse point. / path: {v1} / error: {v8996} / path': {v1} / name: {v8999}"
                        let v13111 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v13112 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v13113 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13110 v13112 
                        let _v13111 = v13113 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v13114 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v13115 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13110 v13114 
                        let _v13111 = v13115 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v13116 : string = "std::io::Error::new(std::io::ErrorKind::Other, &*$0)"
                        let v13117 : std_io_Error = Fable.Core.RustInterop.emitRustExpr v13110 v13116 
                        let _v13111 = v13117 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v13118 : std_io_Error = v13110 
                        let _v13111 = v13118 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v13119 : std_io_Error = v13110 
                        let _v13111 = v13119 
                        #endif
#else
                        let v13120 : std_io_Error = v13110 
                        let _v13111 = v13120 
                        #endif
                        let v13121 : std_io_Error = _v13111 
                        let v13124 : unit = ()
                        
#if FABLE_COMPILER || WASM || CONTRACT
                        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
                        let v13125 : string = "Err($0)"
                        let v13126 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13121 v13125 
                        let _v13124 = v13126 
                        #endif
#if FABLE_COMPILER_RUST && WASM
                        let v13127 : string = "Err($0)"
                        let v13128 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13121 v13127 
                        let _v13124 = v13128 
                        #endif
#if FABLE_COMPILER_RUST && CONTRACT
                        let v13129 : string = "Err($0)"
                        let v13130 : Result<std_path_PathBuf, std_io_Error> = Fable.Core.RustInterop.emitRustExpr v13121 v13129 
                        let _v13124 = v13130 
                        #endif
#if FABLE_COMPILER_TYPESCRIPT
                        let v13131 : Result<std_path_PathBuf, std_io_Error> = v13121 |> Error
                        let _v13124 = v13131 
                        #endif
#if FABLE_COMPILER_PYTHON
                        let v13132 : Result<std_path_PathBuf, std_io_Error> = v13121 |> Error
                        let _v13124 = v13132 
                        #endif
#else
                        let v13133 : Result<std_path_PathBuf, std_io_Error> = v13121 |> Error
                        let _v13124 = v13133 
                        #endif
                        let v13134 : Result<std_path_PathBuf, std_io_Error> = _v13124 
                        v13134
            let _v10 = v13138 
            #endif
            let v13139 : Result<std_path_PathBuf, std_io_Error> = _v10 
            let v13142 : unit = ()
            
#if FABLE_COMPILER || WASM || CONTRACT
            
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
            let v13143 : string = "$0.is_err()"
            let v13144 : bool = Fable.Core.RustInterop.emitRustExpr v13139 v13143 
            let _v13142 = v13144 
            #endif
#if FABLE_COMPILER_RUST && WASM
            let v13145 : string = "$0.is_err()"
            let v13146 : bool = Fable.Core.RustInterop.emitRustExpr v13139 v13145 
            let _v13142 = v13146 
            #endif
#if FABLE_COMPILER_RUST && CONTRACT
            let v13147 : string = "$0.is_err()"
            let v13148 : bool = Fable.Core.RustInterop.emitRustExpr v13139 v13147 
            let _v13142 = v13148 
            #endif
#if FABLE_COMPILER_TYPESCRIPT
            let _v13142 = true 
            #endif
#if FABLE_COMPILER_PYTHON
            let _v13142 = true 
            #endif
#else
            let _v13142 = true 
            #endif
            let v13149 : bool = _v13142 
            v13149
        else
            false
    if v13151 then
        let v13152 : bool = true
        method7(v13152, v1)
    let v13153 : bool = method9(v1)
    let v13154 : bool = v13153 = false
    if v13154 then
        let v13155 : unit = ()
        
#if FABLE_COMPILER || WASM || CONTRACT
        
#if FABLE_COMPILER_RUST && !WASM && !CONTRACT
        let v13156 : string = "true; #[cfg(windows)] std::os::windows::fs::symlink_dir(&*$0, &*$1).unwrap()"
        let v13157 : bool = Fable.Core.RustInterop.emitRustExpr struct (v0, v1) v13156 
        let v13158 : string = "true; #[cfg(unix)] std::os::unix::fs::symlink(&*$0, &*$1).unwrap()"
        let v13159 : bool = Fable.Core.RustInterop.emitRustExpr struct (v0, v1) v13158 
        let _v13155 = () 
        #endif
#if FABLE_COMPILER_RUST && WASM
        let _v13155 = () 
        #endif
#if FABLE_COMPILER_RUST && CONTRACT
        let _v13155 = () 
        #endif
#if FABLE_COMPILER_TYPESCRIPT
        let _v13155 = () 
        #endif
#if FABLE_COMPILER_PYTHON
        let _v13155 = () 
        #endif
#else
        let v13160 : System.IO.FileSystemInfo = System.IO.Directory.CreateSymbolicLink (v1, v0)
        let _v13155 = () 
        #endif
        _v13155 
        ()
and closure57 (v0 : string) (v1 : string) : unit =
    method90(v0, v1)
and closure56 () (v0 : string) : (string -> unit) =
    closure57(v0)
and closure59 (v0 : string) (v1 : string) : string =
    method56(v0, v1)
and closure58 () (v0 : string) : (string -> string) =
    closure59(v0)
let v0 : unit = ()
let v1 : (unit -> unit) = closure0()
let v2 : unit = (fun () -> v1 (); v0) ()
let v16 : (string -> Async<int64>) = closure3()
let delete_directory_async x = v16 x
let v17 : (US6 -> (string -> Async<int64>)) = closure10()
let wait_for_file_access x = v17 x
let v18 : (string -> Async<int64>) = closure13()
let wait_for_file_access_read x = v18 x
let v19 : (string -> Async<string>) = closure14()
let read_all_text_async x = v19 x
let v20 : (string -> (string -> bool)) = closure15()
let file_exists_content x = v20 x
let v21 : (string -> (string -> Async<unit>)) = closure17()
let write_all_text_async x = v21 x
let v22 : (string -> (string -> Async<unit>)) = closure19()
let write_all_text_exists x = v22 x
let v23 : (string -> Async<int64>) = closure21()
let delete_file_async x = v23 x
let v24 : (string -> (string -> Async<int64>)) = closure23()
let move_file_async x = v24 x
let v25 : (string -> Async<string option>) = closure26()
let read_all_text_retry_async x = v25 x
let v26 : (unit -> string) = closure32()
let create_temp_path () = v26 ()
let v27 : (unit -> struct (string * System.IDisposable)) = closure34()
let create_temp_dir () = v27 ()
let v28 : (string -> struct (string * System.IDisposable)) = closure43()
let create_temp_dir' x = v28 x
let v29 : (unit -> string) = closure44()
let get_source_directory () = v29 ()
let v30 : (string -> string) = closure45()
let normalize_path x = v30 x
let v31 : (string -> string) = closure50()
let new_file_uri x = v31 x
let v32 : (unit -> string) = closure51()
let get_workspace_root () = v32 ()
let v33 : (bool -> unit) = closure54()
let init_trace_file x = v33 x
let v34 : (string -> (string -> unit)) = closure56()
let link_directory x = v34 x
let v35 : (string -> (string -> string)) = closure58()
let (</>) x = v35 x
()
