anchor.diff:                  struct (violation, world)
           | Some violation -> struct (violation, world)
   
  -    let evalgetEyeFrustum3dImposterBinding fnName exprs originOpt world =
  +    let evalGetEyeFrustum3dImposterBinding fnName exprs originOpt world =
           let struct (evaleds, world) = World.evalManyInternal exprs world
           match Array.tryFind (function Scripting.Violation _ -> true | _ -> false) evaleds with
           | None ->
  
positive.code:                 struct (violation, world)
          | Some violation -> struct (violation, world)
  
      let evalTryReloadAssetsBinding fnName exprs originOpt world =
          let struct (evaleds, world) = World.evalManyInternal exprs world
          match Array.tryFind (function Scripting.Violation _ -> true | _ -> false) evaleds with
  
negative.code:             struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getMasterSongVolume' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let setMasterAudioVolume volume world =
          let oldWorld = world
          try
              let volume =
                  match ScriptingSystem.tryExport typeof<Single> volume world with
                  | Some value -> value :?> Single
                  | None -> failwith "Invalid argument type for 'volume'; expecting a value convertable to Single."
              let result = World.setMasterAudioVolume volume world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setMasterAudioVolume' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let setMasterSoundVolume volume world =
          let oldWorld = world
          try
              let volume =
                  match ScriptingSystem.tryExport typeof<Single> volume world with
                  | Some value -> value :?> Single
                  | None -> failwith "Invalid argument type for 'volume'; expecting a value convertable to Single."
              let result = World.setMasterSoundVolume volume world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setMasterSoundVolume' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let setMasterSongVolume volume world =
          let oldWorld = world
          try
              let volume =
                  match ScriptingSystem.tryExport typeof<Single> volume world with
                  | Some value -> value :?> Single
                  | None -> failwith "Invalid argument type for 'volume'; expecting a value convertable to Single."
              let result = World.setMasterSongVolume volume world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setMasterSongVolume' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let playSong timeToFadeInSongMs timeToFadeOutSongMs volume start song world =
          let oldWorld = world
          try
              let timeToFadeInSongMs =
                  match ScriptingSystem.tryExport typeof<Int32> timeToFadeInSongMs world with
                  | Some value -> value :?> Int32
                  | None -> failwith "Invalid argument type for 'timeToFadeInSongMs'; expecting a value convertable to Int32."
              let timeToFadeOutSongMs =
                  match ScriptingSystem.tryExport typeof<Int32> timeToFadeOutSongMs world with
                  | Some value -> value :?> Int32
                  | None -> failwith "Invalid argument type for 'timeToFadeOutSongMs'; expecting a value convertable to Int32."
              let volume =
                  match ScriptingSystem.tryExport typeof<Single> volume world with
                  | Some value -> value :?> Single
                  | None -> failwith "Invalid argument type for 'volume'; expecting a value convertable to Single."
              let start =
                  match ScriptingSystem.tryExport typeof<Double> start world with
                  | Some value -> value :?> Double
                  | None -> failwith "Invalid argument type for 'start'; expecting a value convertable to Double."
              let song =
                  match ScriptingSystem.tryExport typeof<AssetTag<Song>> song world with
                  | Some value -> value :?> AssetTag<Song>
                  | None -> failwith "Invalid argument type for 'song'; expecting a value convertable to AssetTag`1."
              let result = World.playSong timeToFadeInSongMs timeToFadeOutSongMs volume start song world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'playSong' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let playSong6 timeToFadeInSongMs timeToFadeOutSongMs volume start songPackageName songAssetName world =
          let oldWorld = world
          try
              let timeToFadeInSongMs =
                  match ScriptingSystem.tryExport typeof<Int32> timeToFadeInSongMs world with
                  | Some value -> value :?> Int32
                  | None -> failwith "Invalid argument type for 'timeToFadeInSongMs'; expecting a value convertable to Int32."
              let timeToFadeOutSongMs =
                  match ScriptingSystem.tryExport typeof<Int32> timeToFadeOutSongMs world with
                  | Some value -> value :?> Int32
                  | None -> failwith "Invalid argument type for 'timeToFadeOutSongMs'; expecting a value convertable to Int32."
              let volume =
                  match ScriptingSystem.tryExport typeof<Single> volume world with
                  | Some value -> value :?> Single
                  | None -> failwith "Invalid argument type for 'volume'; expecting a value convertable to Single."
              let start =
                  match ScriptingSystem.tryExport typeof<Double> start world with
                  | Some value -> value :?> Double
                  | None -> failwith "Invalid argument type for 'start'; expecting a value convertable to Double."
              let songPackageName =
                  match ScriptingSystem.tryExport typeof<String> songPackageName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'songPackageName'; expecting a value convertable to String."
              let songAssetName =
                  match ScriptingSystem.tryExport typeof<String> songAssetName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'songAssetName'; expecting a value convertable to String."
              let result = World.playSong7 timeToFadeInSongMs timeToFadeOutSongMs volume start songPackageName songAssetName world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'playSong6' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let playSound volume sound world =
          let oldWorld = world
          try
              let volume =
                  match ScriptingSystem.tryExport typeof<Single> volume world with
                  | Some value -> value :?> Single
                  | None -> failwith "Invalid argument type for 'volume'; expecting a value convertable to Single."
              let sound =
                  match ScriptingSystem.tryExport typeof<AssetTag<Sound>> sound world with
                  | Some value -> value :?> AssetTag<Sound>
                  | None -> failwith "Invalid argument type for 'sound'; expecting a value convertable to AssetTag`1."
              let result = World.playSound volume sound world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'playSound' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let playSound3 volume soundPackageName soundAssetName world =
          let oldWorld = world
          try
              let volume =
                  match ScriptingSystem.tryExport typeof<Single> volume world with
                  | Some value -> value :?> Single
                  | None -> failwith "Invalid argument type for 'volume'; expecting a value convertable to Single."
              let soundPackageName =
                  match ScriptingSystem.tryExport typeof<String> soundPackageName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'soundPackageName'; expecting a value convertable to String."
              let soundAssetName =
                  match ScriptingSystem.tryExport typeof<String> soundAssetName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'soundAssetName'; expecting a value convertable to String."
              let result = World.playSound4 volume soundPackageName soundAssetName world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'playSound3' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let fadeOutSong timeToFadeOutSongMs world =
          let oldWorld = world
          try
              let timeToFadeOutSongMs =
                  match ScriptingSystem.tryExport typeof<Int32> timeToFadeOutSongMs world with
                  | Some value -> value :?> Int32
                  | None -> failwith "Invalid argument type for 'timeToFadeOutSongMs'; expecting a value convertable to Int32."
              let result = World.fadeOutSong timeToFadeOutSongMs world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'fadeOutSong' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let stopSong world =
          let oldWorld = world
          try
              let result = World.stopSong world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'stopSong' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let hintAudioPackageUse packageName world =
          let oldWorld = world
          try
              let packageName =
                  match ScriptingSystem.tryExport typeof<String> packageName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'packageName'; expecting a value convertable to String."
              let result = World.hintAudioPackageUse packageName world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'hintAudioPackageUse' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let hintAudioPackageDisuse packageName world =
          let oldWorld = world
          try
              let packageName =
                  match ScriptingSystem.tryExport typeof<String> packageName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'packageName'; expecting a value convertable to String."
              let result = World.hintAudioPackageDisuse packageName world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'hintAudioPackageDisuse' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let reloadAudioAssets world =
          let oldWorld = world
          try
              let result = World.reloadAudioAssets world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'reloadAudioAssets' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let hintRenderPackageUse2d packageName world =
          let oldWorld = world
          try
              let packageName =
                  match ScriptingSystem.tryExport typeof<String> packageName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'packageName'; expecting a value convertable to String."
              let result = World.hintRenderPackageUse2d packageName world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'hintRenderPackageUse2d' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let hintRenderPackageDisuse2d packageName world =
          let oldWorld = world
          try
              let packageName =
                  match ScriptingSystem.tryExport typeof<String> packageName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'packageName'; expecting a value convertable to String."
              let result = World.hintRenderPackageDisuse2d packageName world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'hintRenderPackageDisuse2d' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let reloadRenderAssets2d world =
          let oldWorld = world
          try
              let result = World.reloadRenderAssets2d world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Void> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'reloadRenderAssets2d' due to: " + scstring exn, ValueNone)
              struct (violation, World.choose oldWorld)
  
      let localizeBodyShape extent bodyShape world =
  