#if !FUSION_DEV

#region Assets/Photon/FusionCodeGen/AssemblyInfo.cs

[assembly: Fusion.NetworkAssemblyIgnore]

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaver.Cache.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL
namespace Fusion.CodeGen {

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Runtime.CompilerServices;
  using Mono.Cecil;
  using Mono.Cecil.Cil;
  using Mono.Cecil.Rocks;
  using static Fusion.CodeGen.ILWeaverOpCodes;

  partial class ILWeaver {

    private Dictionary<int, FixedBufferInfo> _fixedBuffers = new Dictionary<int, FixedBufferInfo>();
    private Dictionary<string, ElementReaderWriterInfo> _readerWriters = new Dictionary<string, ElementReaderWriterInfo>();
    private Dictionary<string, TypeDefinition> _unitySurrogateTypes = new Dictionary<string, TypeDefinition>();
    private Dictionary<string, TypeDefinition> _blittableType = new Dictionary<string, TypeDefinition>();
    private ElementReaderWriterInfo _instanceReaderWriter = new ElementReaderWriterInfo() {
      InitializeInstance = il => { },
      LoadInstance = il => il.Append(Ldarg_0()),
    };

    private TypeReference CacheGetBlittableType(ILWeaverAssembly asm, PropertyDefinition property, TypeReference elementType) {

      if (_blittableType.TryGetValue(elementType.FullName, out var blittableType)) {
        return blittableType;
      } else if (elementType.IsFloat() || elementType.IsVector2() || elementType.IsVector3()) {
        blittableType = new TypeDefinition("Fusion.CodeGen", $"Blittable{elementType.Name}@{elementType.Name}",
          TypeAttributes.NotPublic | TypeAttributes.AnsiClass | TypeAttributes.ExplicitLayout | TypeAttributes.Sealed | TypeAttributes.Serializable | TypeAttributes.BeforeFieldInit,
          asm.ValueType);

        blittableType.AddTo(asm.CecilAssembly);
        blittableType.AddInterface<INetworkStruct>(asm);
        blittableType.AddAttribute<NetworkStructWeavedAttribute, int>(asm, GetTypeWordCount(asm, elementType));

        if (elementType.IsFloat()) {
          blittableType.Fields.Add(new FieldDefinition("Value", FieldAttributes.Public, asm.WordSizedPrimitive));
        } else if (elementType.IsVector2()) {
          blittableType.Fields.Add(new FieldDefinition("X", FieldAttributes.Public, asm.WordSizedPrimitive));
          blittableType.Fields.Add(new FieldDefinition("Y", FieldAttributes.Public, asm.WordSizedPrimitive));
        } else if (elementType.IsVector3()) {
          blittableType.Fields.Add(new FieldDefinition("X", FieldAttributes.Public, asm.WordSizedPrimitive));
          blittableType.Fields.Add(new FieldDefinition("Y", FieldAttributes.Public, asm.WordSizedPrimitive));
          blittableType.Fields.Add(new FieldDefinition("Z", FieldAttributes.Public, asm.WordSizedPrimitive));
        }

        for (int i = 0; i < blittableType.Fields.Count; ++i) {
          blittableType.Fields[i].Offset = i * Allocator.REPLICATE_WORD_SIZE;
        }

        _blittableType.Add(elementType.FullName, blittableType);
        return blittableType;
      } else {
        return null;
      }
    }

    private FixedBufferInfo CacheGetFixedBuffer(ILWeaverAssembly asm, int wordCount) {
      if (!_fixedBuffers.TryGetValue(wordCount, out var entry)) {
        // fixed buffers could be included directly in structs, but then again it would be impossible to provide a custom drawer;
        // that's why there's this proxy struct
        var storageType = new TypeDefinition("Fusion.CodeGen", $"FixedStorage@{wordCount}",
          TypeAttributes.ExplicitLayout | TypeAttributes.AnsiClass | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit | TypeAttributes.Serializable,
          asm.ValueType);

        storageType.AddTo(asm.CecilAssembly);
        storageType.AddInterface<INetworkStruct>(asm);
        storageType.AddAttribute<NetworkStructWeavedAttribute, int>(asm, wordCount);

        FieldDefinition bufferField;
        if (Allocator.REPLICATE_WORD_SIZE == sizeof(int)) {
          bufferField = CreateFixedBufferField(asm, storageType, $"Data", asm.Import(typeof(int)), wordCount);
          bufferField.Offset = 0;

          // Unity debugger seems to copy only the first element of a buffer,
          // the rest is garbage when inspected; let's add some additional
          // fields to help it
          for (int i = 1; i < wordCount; ++i) {
            var unityDebuggerWorkaroundField = new FieldDefinition($"_{i}", FieldAttributes.Private | FieldAttributes.NotSerialized, asm.Import<int>());
            unityDebuggerWorkaroundField.Offset = Allocator.REPLICATE_WORD_SIZE * i;
            unityDebuggerWorkaroundField.AddTo(storageType);
          }

        }

        entry = new FixedBufferInfo() {
          Type = storageType,
          PointerField = bufferField
        };

        _fixedBuffers.Add(wordCount, entry);
      }
      return entry;
    }

    static FieldDefinition CreateFixedBufferField(ILWeaverAssembly asm, TypeDefinition type, string fieldName, TypeReference elementType, int elementCount) {
      var fixedBufferType = new TypeDefinition("", $"<{fieldName}>e__FixedBuffer", TypeAttributes.SequentialLayout | TypeAttributes.AnsiClass | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit | TypeAttributes.NestedPublic) {
        BaseType = asm.Import(typeof(ValueType)),
        PackingSize = 0,
        ClassSize = elementCount * elementType.GetPrimitiveSize(),
      };
      fixedBufferType.AddAttribute<CompilerGeneratedAttribute>(asm);
      fixedBufferType.AddAttribute<UnsafeValueTypeAttribute>(asm);
      fixedBufferType.AddTo(type);

      var elementField = new FieldDefinition("FixedElementField", FieldAttributes.Private, elementType);
      elementField.AddTo(fixedBufferType);

      var field = new FieldDefinition(fieldName, FieldAttributes.Public, fixedBufferType);
      field.AddAttribute<FixedBufferAttribute, TypeReference, int>(asm, elementType, elementCount);
      field.AddTo(type);

      return field;
    }


    private ElementReaderWriterInfo MakeElementReaderWriter(ILWeaverAssembly asm, PropertyDefinition property, TypeReference elementType) {

      var interfaceType = asm.Import(typeof(IElementReaderWriter<>)).MakeGenericInstanceType(elementType);

      if (TryGetNetworkWrapperType(elementType, out var wrapInfo)) {
        if (!property.DeclaringType.Is<NetworkBehaviour>()) {
          throw new ILWeaverException($"{elementType} needs wrapping - such types are only supported as NetworkBehaviour properties.");
        }

        var wordCount = GetTypeWordCount(asm, elementType);

        // let's add an interface!
        var behaviour = property.DeclaringType;
        if (!behaviour.Interfaces.Any(x => x.InterfaceType.FullName == interfaceType.FullName)) {
          Log.Debug($"Adding interface {behaviour} {interfaceType}");
          AddIElementReaderWriterImplementation(asm, behaviour, property, elementType, wordCount, isExplicit: true);
        }
        return _instanceReaderWriter;

      } else {
        var readerWriterName = "ReaderWriter@" + elementType.FullName.Replace(".", "_");

        int wordCount;

        if (property.PropertyType.IsString()) {
          wordCount = GetPropertyWordCount(asm, property);
          readerWriterName += $"@{wordCount}";
        } else {
          wordCount = GetTypeWordCount(asm, elementType);
          if (TryGetFloatAccuracy(property, out var accuracy)) {
            uint value = BitConverter.ToUInt32(BitConverter.GetBytes(accuracy), 0);
            readerWriterName += $"@{value:x}";
          }
        }

        if (_readerWriters.TryGetValue(readerWriterName, out var entry)) {
          return entry;
        }

        var readerWriterType = new TypeDefinition("Fusion.CodeGen", readerWriterName,
          TypeAttributes.AnsiClass | TypeAttributes.Sealed | TypeAttributes.SequentialLayout | TypeAttributes.BeforeFieldInit, asm.ValueType);

        // without this, VS debugger will crash
        readerWriterType.PackingSize = 0;
        readerWriterType.ClassSize = 1;

        readerWriterType.AddTo(asm.CecilAssembly);

        AddIElementReaderWriterImplementation(asm, readerWriterType, property, elementType, wordCount);

        var instanceField = new FieldDefinition("Instance", FieldAttributes.Public | FieldAttributes.Static, interfaceType);
        instanceField.AddTo(readerWriterType);

        var initializeMethod = new MethodDefinition($"EnsureInitialized", MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig, asm.Import(typeof(void)));
        initializeMethod.AddAttribute<MethodImplAttribute, MethodImplOptions>(asm, MethodImplOptions.AggressiveInlining);
        initializeMethod.AddTo(readerWriterType);

        {
          var il = initializeMethod.Body.GetILProcessor();
          var ret = Instruction.Create(OpCodes.Ret);

          var tmpVar = new VariableDefinition(readerWriterType);
          il.Body.Variables.Add(tmpVar);

          il.Append(Ldsfld(instanceField));
          il.Append(Brtrue_S(ret));

          il.Append(Instruction.Create(OpCodes.Ldloca_S, tmpVar));
          il.Append(Instruction.Create(OpCodes.Initobj, readerWriterType));
          il.Append(Instruction.Create(OpCodes.Ldloc_0));
          il.Append(Instruction.Create(OpCodes.Box, readerWriterType));
          il.Append(Instruction.Create(OpCodes.Stsfld, instanceField));

          il.Append(ret);
        }

        entry = new ElementReaderWriterInfo() {
          InitializeInstance = il => il.Append(Call(initializeMethod)),
          LoadInstance = il => il.Append(Ldsfld(instanceField)),
          Type = readerWriterType
        };

        _readerWriters.Add(readerWriterName, entry);
        return entry;
      }
    }

    private void AddIElementReaderWriterImplementation(ILWeaverAssembly asm, TypeDefinition readerWriterType, PropertyDefinition property, TypeReference elementType, int elementWordCount, bool isExplicit = false) {

      var dataType = asm.Import(typeof(byte*));
      var indexType = asm.Import(typeof(int));
      var interfaceType = asm.Import(typeof(IElementReaderWriter<>)).MakeGenericInstanceType(elementType);
      
      readerWriterType.Interfaces.Add(new InterfaceImplementation(interfaceType));

      var visibility = isExplicit ? MethodAttributes.Private : MethodAttributes.Public;
      var namePrefix = isExplicit ? $"CodeGen@ElementReaderWriter<{elementType.FullName}>." : "";

      var readMethod = new MethodDefinition($"{namePrefix}Read",
        visibility | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual,
        elementType);

      readMethod.Parameters.Add(new ParameterDefinition("data", ParameterAttributes.None, dataType));
      readMethod.Parameters.Add(new ParameterDefinition("index", ParameterAttributes.None, indexType));
      readMethod.AddAttribute<MethodImplAttribute, MethodImplOptions>(asm, MethodImplOptions.AggressiveInlining);
      readMethod.AddTo(readerWriterType);

      var writeMethod = new MethodDefinition($"{namePrefix}Write",
        visibility | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual,
        asm.Void);

      writeMethod.Parameters.Add(new ParameterDefinition("data", ParameterAttributes.None, dataType));
      writeMethod.Parameters.Add(new ParameterDefinition("index", ParameterAttributes.None, indexType));
      writeMethod.Parameters.Add(new ParameterDefinition("val", ParameterAttributes.None, elementType));
      writeMethod.AddAttribute<MethodImplAttribute, MethodImplOptions>(asm, MethodImplOptions.AggressiveInlining);
      writeMethod.AddTo(readerWriterType);

      var getElementWordCountMethod = new MethodDefinition($"{namePrefix}GetElementWordCount",
        visibility | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual,
        asm.Import(typeof(int)));

      getElementWordCountMethod.AddAttribute<MethodImplAttribute, MethodImplOptions>(asm, MethodImplOptions.AggressiveInlining);
      
      if (isExplicit) {
        readMethod.Overrides.Add(interfaceType.GetGenericInstanceMethodOrThrow(nameof(IElementReaderWriter<int>.Read)));
        writeMethod.Overrides.Add(interfaceType.GetGenericInstanceMethodOrThrow(nameof(IElementReaderWriter<int>.Write)));
        getElementWordCountMethod.Overrides.Add(interfaceType.GetGenericInstanceMethodOrThrow(nameof(IElementReaderWriter<int>.GetElementWordCount)));
      }

      var getterMethodIL = readMethod.Body.GetILProcessor();
      var setterMethodIL = writeMethod.Body.GetILProcessor();

      InjectValueAccessor(asm, getterMethodIL, setterMethodIL, property, elementType, OpCodes.Ldarg_3, (il, offset) => {
        LoadArrayElementAddress(il, OpCodes.Ldarg_1, OpCodes.Ldarg_2, elementWordCount, offset);
      }, false);

      getElementWordCountMethod.AddTo(readerWriterType);
      {
        var il = getElementWordCountMethod.Body.GetILProcessor();
        il.Append(Ldc_I4(elementWordCount));
        il.Append(Ret());
      }
    }


    private string TypeNameToIdentifier(TypeReference type, string prefix) {
      string result = type.FullName;
      result = result.Replace("`1", "");
      result = result.Replace("`2", "");
      result = result.Replace("`3", "");
      result = result.Replace(".", "_");
      result = prefix + result;
      return result;
    }

    private TypeDefinition CacheGetUnitySurrogate(ILWeaverAssembly asm, PropertyDefinition property) {
      var type = property.PropertyType;

      GenericInstanceType baseType;
      string surrogateName;

      if (type.IsNetworkDictionary(out var keyType, out var valueType)) {
        keyType = asm.Import(keyType);
        valueType = asm.Import(valueType);
        var keyReaderWriterType = MakeElementReaderWriter(asm, property, keyType).Type;
        var valueReaderWriterType = MakeElementReaderWriter(asm, property, valueType).Type;
        baseType = asm.Import(typeof(Fusion.Internal.UnityDictionarySurrogate<,,,>)).MakeGenericInstanceType(keyType, keyReaderWriterType, valueType, valueReaderWriterType);
        surrogateName = "UnityDictionarySurrogate@" + keyReaderWriterType.Name + "@" + valueReaderWriterType.Name;
      } else if (type.IsNetworkArray(out var elementType)) {
        elementType = asm.Import(elementType);
        var readerWriterType = MakeElementReaderWriter(asm, property, elementType).Type;
        baseType = asm.Import(typeof(Fusion.Internal.UnityArraySurrogate<,>)).MakeGenericInstanceType(elementType, readerWriterType);
        surrogateName = "UnityArraySurrogate@" + readerWriterType.Name;
      } else if (type.IsNetworkList(out elementType)) {
        elementType = asm.Import(elementType);
        var readerWriterType = MakeElementReaderWriter(asm, property, elementType).Type;
        baseType = asm.Import(typeof(Fusion.Internal.UnityLinkedListSurrogate<,>)).MakeGenericInstanceType(elementType, readerWriterType);
        surrogateName = "UnityLinkedListSurrogate@" + readerWriterType.Name;
      } else {
        var readerWriterType = MakeElementReaderWriter(asm, property, property.PropertyType).Type;
        baseType = asm.Import(typeof(Fusion.Internal.UnityValueSurrogate<,>)).MakeGenericInstanceType(property.PropertyType, readerWriterType);
        surrogateName = "UnityValueSurrogate@" + readerWriterType.Name;
      }

      if (!_unitySurrogateTypes.TryGetValue(surrogateName, out var surrogateType)) {
        surrogateType = new TypeDefinition("Fusion.CodeGen", surrogateName,
          TypeAttributes.NotPublic | TypeAttributes.AnsiClass | TypeAttributes.Serializable | TypeAttributes.BeforeFieldInit,
          baseType);

        surrogateType.AddTo(asm.CecilAssembly);
        surrogateType.AddEmptyConstructor(asm);

        _unitySurrogateTypes.Add(surrogateName, surrogateType);
      }
      return surrogateType;
    }

    struct ElementReaderWriterInfo {
      public Action<ILProcessor> InitializeInstance;
      public Action<ILProcessor> LoadInstance;
      public TypeDefinition Type;
    }

    struct FixedBufferInfo {
      public FieldDefinition PointerField;
      public TypeDefinition Type;
    }
  }
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaver.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL
namespace Fusion.CodeGen {
  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using UnityEditor;
  using UnityEditor.Compilation;
  using UnityEngine;
  using System.Runtime.CompilerServices;
  using static Fusion.CodeGen.ILWeaverOpCodes;
  using Mono.Cecil;
  using Mono.Cecil.Cil;
  using Mono.Cecil.Rocks;
  using Mono.Collections.Generic;
  using CompilerAssembly = UnityEditor.Compilation.Assembly;
  using FieldAttributes = Mono.Cecil.FieldAttributes;
  using MethodAttributes = Mono.Cecil.MethodAttributes;
  using ParameterAttributes = Mono.Cecil.ParameterAttributes;

  public unsafe partial class ILWeaver {


    void AddUnmanagedType<T>() where T : unmanaged {
      AddUnmanagedType<T>(sizeof(T));
    }

    void AddUnmanagedType<T>(int size) where T : unmanaged {
      unsafe {
        var wordCount = Native.WordCount(size, Allocator.REPLICATE_WORD_SIZE);
        _typeData.Add(typeof(T).FullName, new TypeMetaData(wordCount));
      }
    }

    void SetDefaultTypeData() {
      _networkedBehaviourTypeData = new Dictionary<string, BehaviourMetaData>();
      _typeData = new Dictionary<string, TypeMetaData>();
      _rpcCount = new Dictionary<string, int>();

      _typeData.Add("NetworkedObject", new TypeMetaData(2));

      AddUnmanagedType<bool>(sizeof(int));

      AddUnmanagedType<byte>();
      AddUnmanagedType<sbyte>();

      AddUnmanagedType<Int16>();
      AddUnmanagedType<UInt16>();

      AddUnmanagedType<Int32>();
      AddUnmanagedType<UInt32>();

      AddUnmanagedType<Int64>();
      AddUnmanagedType<UInt64>();

      AddUnmanagedType<float>();
      AddUnmanagedType<double>();

      AddUnmanagedType<Vector2>();
      AddUnmanagedType<Vector3>();
      AddUnmanagedType<Vector4>();
      AddUnmanagedType<Quaternion>();
      AddUnmanagedType<Matrix4x4>();

      AddUnmanagedType<Vector2Int>();
      AddUnmanagedType<Vector3Int>();

      AddUnmanagedType<BoundingSphere>();
      AddUnmanagedType<Bounds>();
      AddUnmanagedType<Rect>();
      AddUnmanagedType<Color>();

      AddUnmanagedType<BoundsInt>();
      AddUnmanagedType<RectInt>();
      AddUnmanagedType<Color32>();
      
      AddUnmanagedType<Guid>();
    }

    public static bool IsEditorAssemblyPath(string path) {
      return path.Contains("-Editor") || path.Contains(".Editor");
    }

    struct WrapInfo {
      public MethodDefinition WrapMethod;
      public MethodDefinition UnwrapMethod;
      public TypeReference WrapperType;
      public TypeReference Type;
      public int MaxRawByteCount;
      public bool UnwrapByRef;
      public bool IsRaw => MaxRawByteCount > 0;
    }

    bool TryGetNetworkWrapperType(TypeReference type, out WrapInfo result) {
      if (type == null) {
        result = default;
        return false;
      }

      var definition = type.TryResolve();
      if (definition == null) {
        result = default;
        return false;
      }

      int rawByteCount = 0;

      if (definition.GetSingleOrDefaultMethodWithAttribute<NetworkSerializeMethodAttribute>(out var wrapAttribute, out var wrapMethod)) {
        wrapAttribute.TryGetAttributeProperty<int>(nameof(NetworkSerializeMethodAttribute.MaxSize), out rawByteCount);

        if (rawByteCount > 0) {
          try {
            wrapMethod.ThrowIfNotStatic()
                      .ThrowIfNotPublic()
                      .ThrowIfParameterCount(3)
                      .ThrowIfParameter(0, typeof(NetworkRunner))
                      .ThrowIfParameter(1, type)
                      .ThrowIfParameter(2, typeof(byte*))
                      .ThrowIfReturnType(typeof(int));
          } catch (Exception ex) {
            throw new ILWeaverException($"Method marked with {nameof(NetworkSerializeMethodAttribute)} has an invalid signature RAW", ex);
          }
        } else {
          try {
            wrapMethod.ThrowIfNotStatic()
                      .ThrowIfNotPublic()
                      .ThrowIfParameterCount(2)
                      .ThrowIfParameter(0, typeof(NetworkRunner))
                      .ThrowIfParameter(1, type);
          } catch (Exception ex) {
            throw new ILWeaverException($"Method marked with {nameof(NetworkSerializeMethodAttribute)} has an invalid signature", ex);
          }
        }
      }

      bool cacheUnwrap = false;

      if (definition.GetSingleOrDefaultMethodWithAttribute<NetworkDeserializeMethodAttribute>(out var unwrapAttribute, out var unwrapMethod)) {
        if (wrapMethod == null) {
          throw new ILWeaverException($"Method marked with {nameof(NetworkDeserializeMethodAttribute)}, but there is no method marked with {nameof(NetworkSerializeMethodAttribute)}: {unwrapMethod}");
        }

        if (rawByteCount > 0) {
          try {
            unwrapMethod.ThrowIfNotStatic()
                        .ThrowIfNotPublic()
                        .ThrowIfReturnType(typeof(int))
                        .ThrowIfParameterCount(3)
                        .ThrowIfParameter(0, typeof(NetworkRunner))
                        .ThrowIfParameter(1, typeof(byte*))
                        .ThrowIfParameter(2, type, isByReference: true);
            cacheUnwrap = true;
          } catch (Exception ex) {
            throw new ILWeaverException($"Method marked with {nameof(NetworkDeserializeMethodAttribute)} has an invalid signature RAW", ex);
          }
        } else {
          try {
            unwrapMethod.ThrowIfNotStatic()
                        .ThrowIfNotPublic()
                        .ThrowIfParameter(0, typeof(NetworkRunner))
                        .ThrowIfParameter(1, wrapMethod.ReturnType);
            
            if (unwrapMethod.Parameters.Count == 3) {
              unwrapMethod.ThrowIfReturnType(typeof(void))
                          .ThrowIfParameter(2, type, isByReference: true);
              cacheUnwrap = true;
            } else if (unwrapMethod.Parameters.Count == 2) {
              unwrapMethod.ThrowIfReturnType(type);
            } else {
              throw new ILWeaverException($"Expected 2 or 3 parameters");
            }
          } catch (Exception ex) {
            throw new ILWeaverException($"Method marked with {nameof(NetworkDeserializeMethodAttribute)} has an invalid signature", ex);
          }
          
        }
      } else if (wrapMethod != null) {
        throw new ILWeaverException($"Method marked with {nameof(NetworkSerializeMethodAttribute)}, but there is no method marked with {nameof(NetworkDeserializeMethodAttribute)}: {wrapMethod}");
      }


      if (wrapMethod != null && unwrapMethod != null) {
        result = new WrapInfo() {
          MaxRawByteCount = rawByteCount,
          UnwrapMethod    = unwrapMethod,
          WrapMethod      = wrapMethod,
          WrapperType     = rawByteCount > 0 ? null : wrapMethod.ReturnType,
          Type            = type,
          UnwrapByRef     = cacheUnwrap,
        };
        return true;
      }

      return TryGetNetworkWrapperType(definition.BaseType, out result);
    }

    TypeDefinition FindNetworkedBehaviourTypeDef(TypeDefinition type) {
      if (type == null || type.IsClass == false || type.BaseType == null) {
        return null;
      }

      if (type.BaseType.Name == nameof(NetworkBehaviour)) {
        return type.BaseType.TryResolve();
      }

      return FindNetworkedBehaviourTypeDef(type.BaseType.TryResolve());
    }

    class TypeMetaData {
      public TypeReference Reference;
      public TypeDefinition Definition;
      public int WordCount;

      public TypeMetaData() {
      }

      public TypeMetaData(int wordCount) {
        WordCount = wordCount;
      }
    }

    class BehaviourMetaData {
      public TypeDefinition Definition;
      public int BlockCount;
    }



    const string REF_FIELD_NAME = "Ref";
    const string PTR_FIELD_NAME = nameof(NetworkBehaviour.Ptr);
    const string OBJECT_FIELD_NAME = nameof(NetworkBehaviour.Object);
    const string RUNNER_FIELD_NAME = nameof(NetworkBehaviour.Runner);

    const string FIND_OBJECT_METHOD_NAME = nameof(NetworkRunner.FindObject);

    Dictionary<string, TypeMetaData> _typeData = new Dictionary<string, TypeMetaData>();
    Dictionary<string, BehaviourMetaData> _networkedBehaviourTypeData = new Dictionary<string, BehaviourMetaData>();
    Dictionary<string, int> _rpcCount = new Dictionary<string, int>();


    internal readonly ILWeaverLog Log;

    public ILWeaver(ILWeaverLog log) {
      Log = log;
      SetDefaultTypeData();
    }



    FieldReference GetFieldFromNetworkedBehaviour(ILWeaverAssembly assembly, TypeDefinition type, string fieldName) {
      if (type.Name == nameof(NetworkBehaviour)) {
        foreach (var fieldDefinition in type.Fields) {
          if (fieldDefinition.Name == fieldName) {
            return assembly.CecilAssembly.MainModule.ImportReference(fieldDefinition);
          }
        }
      }

      if (type.IsSubclassOf<NetworkBehaviour>()) {
        return GetFieldFromNetworkedBehaviour(assembly, type.BaseType.TryResolve(), fieldName);
      }

      Assert.Fail();
      return null;
    }

    MethodReference GetMetaAttributeConstructor(ILWeaverAssembly asm) {
      return asm.CecilAssembly.MainModule.ImportReference(typeof(NetworkBehaviourWeavedAttribute).GetConstructors()[0]);
    }

    TypeReference ImportType<T>(ILWeaverAssembly asm) {
      return asm.CecilAssembly.MainModule.ImportReference(typeof(T));
    }

    int GetNetworkBehaviourWordCount(ILWeaverAssembly asm, TypeDefinition type) {
      if (type.Name == nameof(NetworkBehaviour)) {
        return 0;
      }

      // has to be network behaviour
      Assert.Always(type.IsSubclassOf<NetworkBehaviour>());

      // make sure parent is weaved
      WeaveBehaviour(asm, type);

      // assert this.. but should always be true
      Assert.Always(type.HasAttribute<NetworkBehaviourWeavedAttribute>());

      // this always has to exist
      return _networkedBehaviourTypeData[type.FullName].BlockCount;
    }

    FieldDefinition FindBackingField(TypeDefinition type, string property) {
      // compute backing field name...
      var backingFieldName = $"<{property}>k__BackingField";

      // find backing field
      return type.Fields.FirstOrDefault(x => x.IsPrivate && x.Name == backingFieldName);
    }

    void LoadDataAddress(ILProcessor il, FieldReference field, int wordCount) {
      il.Append(Instruction.Create(OpCodes.Ldarg_0));
      il.Append(Instruction.Create(OpCodes.Ldfld, field));
      il.Append(Instruction.Create(OpCodes.Ldc_I4, wordCount * Allocator.REPLICATE_WORD_SIZE));
      il.Append(Instruction.Create(OpCodes.Add));
    }    

    int GetWordCount(ILWeaverAssembly asm, WrapInfo wrapInfo) {
      return wrapInfo.WrapperType != null ? GetTypeWordCount(asm, wrapInfo.WrapperType) : Native.WordCount(wrapInfo.MaxRawByteCount, Allocator.REPLICATE_WORD_SIZE);
    }

    int GetByteCount(ILWeaverAssembly asm, WrapInfo wrapInfo) {
      return GetWordCount(asm, wrapInfo) * Allocator.REPLICATE_WORD_SIZE;
    }

    int GetTypeWordCount(ILWeaverAssembly asm, TypeReference type) {
      if (type.IsPointer || type.IsByReference) {
        type = type.GetElementTypeEx();
      }

      // TODO: what is this?
      if (type.IsNetworkArray(out var elementType)) {
        type = elementType;
      } else if (type.IsNetworkList(out elementType)) {
        type = elementType;
      }

      if (_typeData.TryGetValue(type.FullName, out var data) == false) {
        var typeDefinition = type.TryResolve();
        if (typeDefinition == null) {
          throw new ILWeaverException($"Could not resolve type {type}");
        }

        if (typeDefinition.IsEnum) {
          _typeData.Add(type.FullName, data = new TypeMetaData {
            WordCount = 1,
            Definition = typeDefinition
          });
        } else if (typeDefinition.IsValueType && typeDefinition.Is<INetworkStruct>()) {
          // weave this struct
          WeaveStruct(asm, typeDefinition, type);

          // grab type data
          data = _typeData[type.FullName];
        } else if (type.IsFixedBuffer(out var size)) {
          _typeData.Add(type.FullName, data = new TypeMetaData {
            WordCount = Native.WordCount(size, Allocator.REPLICATE_WORD_SIZE),
            Definition = typeDefinition
          });
        } else if (TryGetNetworkWrapperType(type, out var wrapInfo)) {
          _typeData.Add(type.FullName, data = new TypeMetaData {
            WordCount = GetWordCount(asm, wrapInfo),
            Definition = typeDefinition
          });
        } else {
          if (type.IsValueType) {
            throw new ILWeaverException($"Value type {type} does not implement {nameof(INetworkStruct)}");
          } else {
            throw new ILWeaverException($"Reference type {type} is not supported");
          }
        }
      }

      return data.WordCount;
    }

    int GetByteCount(ILWeaverAssembly asm, TypeReference type) {
      return GetTypeWordCount(asm, type) * Allocator.REPLICATE_WORD_SIZE;
    }

    int GetPropertyWordCount(ILWeaverAssembly asm, PropertyDefinition property) {
      //if (property.PropertyType.Is<NetworkBehaviour>() || property.PropertyType.Is<NetworkObject>()) {
      //  return 2;
      //}

      if (property.PropertyType.IsString()) {
        if (property.DeclaringType.IsValueType) {
          return 1 + GetStringCapacity(property);
        } else {
          return 2 + GetStringCapacity(property);
        }
      }

      if (property.PropertyType.IsNetworkArray()) {
        return GetStaticArrayCapacity(property) * GetTypeWordCount(asm, GetStaticArrayElementType(property.PropertyType));
      }

      if (property.PropertyType.IsNetworkList()) {
        return NetworkLinkedList<int>.META_WORDS + (GetStaticListCapacity(property) * (GetTypeWordCount(asm, GetStaticListElementType(property.PropertyType)) + NetworkLinkedList<int>.ELEMENT_WORDS));
      }
      
      if (property.PropertyType.IsNetworkDictionary()) {
      
        var capacity = GetStaticDictionaryCapacity(property);

        return
          // meta data (counts, etc)
          NetworkDictionary<int, int>.META_WORD_COUNT                                           +
          
          // buckets
          (capacity)                                                                            +
          
          // entry
          
            // next
            (capacity) +
          
            // key
            (capacity * GetTypeWordCount(asm, GetStaticDictionaryKeyType(property.PropertyType))) +
          
            // value
            (capacity * GetTypeWordCount(asm, GetStaticDictionaryValType(property.PropertyType)));
      }
      

      return GetTypeWordCount(asm, property.PropertyType);
    }

    static void FloatDecompress(ILProcessor il, float accuracy) {
      if (accuracy == 0) {
        il.Append(Instruction.Create(OpCodes.Conv_R4));
      } else {
        il.Append(Instruction.Create(OpCodes.Conv_R4));
        il.Append(Instruction.Create(OpCodes.Ldc_R4, accuracy));
        il.Append(Instruction.Create(OpCodes.Mul));
      }
    }

    void FloatCompress(ILProcessor il, float accuracy) {
      il.Append(Instruction.Create(OpCodes.Ldc_R4, 1.0f / accuracy));
      il.Append(Instruction.Create(OpCodes.Mul));
      il.Append(Instruction.Create(OpCodes.Ldc_R4, 0.5f));
      il.Append(Instruction.Create(OpCodes.Add));
      il.Append(Instruction.Create(OpCodes.Conv_I4));
    }

    int GetStringCapacity(PropertyDefinition property) {
      return Math.Max(1, GetCapacity(property, 16));
    }

    int GetStaticArrayCapacity(PropertyDefinition property) {
      return Math.Max(1, GetCapacity(property, 1));
    }

    int GetStaticListCapacity(PropertyDefinition property) {
      return Math.Max(1, GetCapacity(property, 1));
    }
    
    int GetStaticDictionaryCapacity(PropertyDefinition property) {
      return Primes.GetNextPrime(Math.Max(1, GetCapacity(property, 1)));
    }
    
    int GetCapacity(PropertyDefinition property, int defaultCapacity) {
      int size;

      if (property.TryGetAttribute<CapacityAttribute>(out var attr)) {
        size = (int)attr.ConstructorArguments[0].Value;
      } else {
        size = defaultCapacity;
      }

      return size;
    }

    bool TryGetFloatAccuracy(PropertyDefinition property, out float accuracy ) {
      if (property.TryGetAttribute<AccuracyAttribute>(out var attr)) {
        var obj = attr.ConstructorArguments[0];

        // If the argument is a string, this is using a global Accuracy. Need to look up the value.
        if (obj.Value is string str) {
          accuracy = ILWeaverSettings.GetNamedFloatAccuracy(str);
        } else {
          var val = attr.ConstructorArguments[0].Value;
          if (val is float fval) {
            accuracy = fval;
          } else if (val is double dval) {
            accuracy = (float)dval;
          } else {
            throw new Exception($"Invalid argument type: {val.GetType()}");
          }
        }
        return true;
      } else {
        accuracy = 0.0f; ;
        return false;
      }
    }

    float GetFloatAccuracy(PropertyDefinition property) {
      float accuracy;

      if (property.TryGetAttribute<AccuracyAttribute>(out var attr)) {
        var obj = attr.ConstructorArguments[0];

        // If the argument is a string, this is using a global Accuracy. Need to look up the value.
        if (obj.Value is string str) {
          accuracy = ILWeaverSettings.GetNamedFloatAccuracy(str);
        } else {
          var val = attr.ConstructorArguments[0].Value;
          if (val is float fval) {
            accuracy = fval; 
          } else if (val is double dval) {
            accuracy = (float)dval;
          } else {
            throw new Exception($"Invalid argument type: {val.GetType()}");
          }
        }
      } else {
        accuracy = AccuracyDefaults.DEFAULT_ACCURACY;
      }

      return accuracy;
    }

    TypeReference GetStaticArrayElementType(TypeReference type) {
      return ((GenericInstanceType)type).GenericArguments[0];
    }
    
    TypeReference GetStaticListElementType(TypeReference type) {
      return ((GenericInstanceType)type).GenericArguments[0];
    }
    
    TypeReference GetStaticDictionaryKeyType(TypeReference type) {
      return ((GenericInstanceType)type).GenericArguments[0];
    }
    
    TypeReference GetStaticDictionaryValType(TypeReference type) {
      return ((GenericInstanceType)type).GenericArguments[1];
    }

    void LoadArrayElementAddress(ILProcessor il, OpCode arrayOpCode, OpCode indexOpCode, int elementWordCount, int wordOffset = 0) {
      il.Append(Instruction.Create(arrayOpCode));
      il.Append(Instruction.Create(indexOpCode));
      il.Append(Instruction.Create(OpCodes.Ldc_I4, elementWordCount * Allocator.REPLICATE_WORD_SIZE));
      il.Append(Instruction.Create(OpCodes.Mul));

      if (wordOffset != 0) {
        il.Append(Instruction.Create(OpCodes.Ldc_I4, wordOffset * Allocator.REPLICATE_WORD_SIZE));
        il.Append(Instruction.Create(OpCodes.Add));
      }

      il.Append(Instruction.Create(OpCodes.Add));
    }

    string GetCacheName(string name) {
      return $"cache_<{name}>";
    }

    string GetInspectorFieldName(string name) {
      return $"_{name}";
    }

    void InjectPtrNullCheck(ILWeaverAssembly asm, ILProcessor il, PropertyDefinition property) {
      if (ILWeaverSettings.NullChecksForNetworkedProperties()) {
        var nop = Instruction.Create(OpCodes.Nop);

        il.Append(Instruction.Create(OpCodes.Ldarg_0));
        il.Append(Instruction.Create(OpCodes.Ldfld, asm.NetworkedBehaviour.GetField(PTR_FIELD_NAME)));
        il.Append(Instruction.Create(OpCodes.Ldc_I4_0));
        il.Append(Instruction.Create(OpCodes.Conv_U));
        il.Append(Instruction.Create(OpCodes.Ceq));
        il.Append(Instruction.Create(OpCodes.Brfalse, nop));

        var ctor = typeof(InvalidOperationException).GetConstructors().First(x => x.GetParameters().Length == 1);
        var exnCtor = asm.Import(ctor);

        il.Append(Instruction.Create(OpCodes.Ldstr, $"Error when accessing {property.DeclaringType.Name}.{property.Name}. Networked properties can only be accessed when Spawned() has been called."));
        il.Append(Instruction.Create(OpCodes.Newobj, exnCtor));
        il.Append(Instruction.Create(OpCodes.Throw));
        il.Append(nop);
      }
    }

    

    void InjectValueAccessor(ILWeaverAssembly asm, ILProcessor getIL, ILProcessor setIL, PropertyDefinition property, TypeReference type, OpCode valueOpCode, Action<ILProcessor, int> addressLoader, bool injectNullChecks) {
      if (injectNullChecks) {
        InjectPtrNullCheck(asm, getIL, property);

        if (setIL != null) {
          InjectPtrNullCheck(asm, setIL, property);
        }
      }

      // for pointer types we can simply just return the address we loaded on the stack
      if (type.IsPointer || type.IsByReference) {
        // load address
        addressLoader(getIL, 0);

        // return
        getIL.Append(Instruction.Create(OpCodes.Ret));

        // this has to be null
        Assert.Check(setIL == null);
      } else if (property.PropertyType.IsString()) {

        if (property.DeclaringType.IsValueType) {

          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Call, asm.ReadWriteUtils.GetMethod(nameof(ReadWriteUtilsForWeaver.ReadStringUtf32NoHash), 1)));
          getIL.Append(Instruction.Create(OpCodes.Ret));

          addressLoader(setIL, 0);
          setIL.Append(Instruction.Create(OpCodes.Ldc_I4, GetStringCapacity(property)));
          setIL.Append(Instruction.Create(valueOpCode));
          setIL.Append(Instruction.Create(OpCodes.Call, asm.ReadWriteUtils.GetMethod(nameof(ReadWriteUtilsForWeaver.WriteStringUtf32NoHash), 3)));
          setIL.Append(Instruction.Create(OpCodes.Ret));

        } else {

          var cache = new FieldDefinition(GetCacheName(property.Name), FieldAttributes.Private, asm.CecilAssembly.MainModule.ImportReference(typeof(string)));

          property.DeclaringType.Fields.Add(cache);

          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Ldarg_0));
          getIL.Append(Instruction.Create(OpCodes.Ldflda, cache));
          getIL.Append(Instruction.Create(OpCodes.Call, asm.ReadWriteUtils.GetMethod(nameof(ReadWriteUtilsForWeaver.ReadStringUtf32WithHash), 2)));
          getIL.Append(Instruction.Create(OpCodes.Ret));

          addressLoader(setIL, 0);
          setIL.Append(Instruction.Create(OpCodes.Ldc_I4, GetStringCapacity(property)));
          setIL.Append(Instruction.Create(valueOpCode));
          setIL.Append(Instruction.Create(OpCodes.Ldarg_0));
          setIL.Append(Instruction.Create(OpCodes.Ldflda, cache));
          setIL.Append(Instruction.Create(OpCodes.Call, asm.ReadWriteUtils.GetMethod(nameof(ReadWriteUtilsForWeaver.WriteStringUtf32WithHash), 4)));
          setIL.Append(Instruction.Create(OpCodes.Ret));
        }
      }

      // for primitive values
      else if (type.IsPrimitive) {
        // floats
        if (type.IsFloat()) {
          var accuracy = GetFloatAccuracy(property);

          // getter
          addressLoader(getIL, 0);

          if (accuracy == 0) {
            getIL.Append(Instruction.Create(OpCodes.Ldind_R4));
          } else {
            getIL.Append(Instruction.Create(OpCodes.Ldind_I4));
            getIL.Append(Instruction.Create(OpCodes.Conv_R4));
            getIL.Append(Instruction.Create(OpCodes.Ldc_R4, accuracy));
            getIL.Append(Instruction.Create(OpCodes.Mul));
          }

          getIL.Append(Instruction.Create(OpCodes.Ret));

          // setter
          addressLoader(setIL, 0);

          if (accuracy == 0) {
            setIL.Append(Instruction.Create(valueOpCode));
            setIL.Append(Instruction.Create(OpCodes.Stind_R4));
          } else {
            setIL.Append(Instruction.Create(OpCodes.Ldc_R4, 1f / accuracy));
            setIL.Append(Instruction.Create(valueOpCode));
            var write = asm.ReadWriteUtils.GetMethod("WriteFloat");
            setIL.Append(Instruction.Create(OpCodes.Call, write));
          }

          setIL.Append(Instruction.Create(OpCodes.Ret));
        } else if (type.IsBool()) {
          {
            // return *ptr == 0 ? false : true
            var load_0 = Ldc_I4(0);
            addressLoader(getIL, 0);
            getIL.Append(Ldind_I4());
            getIL.Append(Brfalse_S(load_0));
            getIL.Append(Ldc_I4(1));
            getIL.Append(Ret());
            getIL.Append(load_0);
            getIL.Append(Ret());
          }
          {
            // *ptr = value ? 1 : 0;
            var store = Stind_I4();
            var load_1 = Ldc_I4(1);
            addressLoader(setIL, 0);
            setIL.Append(Instruction.Create(valueOpCode));
            setIL.Append(Brtrue_S(load_1));
            setIL.Append(Ldc_I4(0));
            setIL.Append(Br_S(store));
            setIL.Append(load_1);
            setIL.Append(store);
            setIL.Append(Ret());
          }
        } else {
          // byte, sbyte, short, ushort, int, uint
          addressLoader(getIL, 0);
          getIL.Append(Ldind(type));
          getIL.Append(Instruction.Create(OpCodes.Ret));

          addressLoader(setIL, 0);
          setIL.Append(Instruction.Create(valueOpCode));
          setIL.Append(Stind(type));
          setIL.Append(Instruction.Create(OpCodes.Ret));
        }
      } else if (TryGetNetworkWrapperType(type, out var wrapInfo)) {

        FieldDefinition field = null;
        //if (wrapInfo.UnwrapByRef) {
        //  cache = new FieldDefinition(GetCacheName(property.Name), FieldAttributes.Private, wrapInfo.Type);
        //}

        // getter
        using (var ctx = new MethodContext(asm, getIL.Body.Method, addressGetter: (x) => addressLoader(x, 0))) {
          if (field != null) {
            property.DeclaringType.Fields.Add(field);
            WeaveNetworkUnwrap(asm, getIL, ctx, wrapInfo, type, previousValue: field);
          } else {
            WeaveNetworkUnwrap(asm, getIL, ctx, wrapInfo, type);
          }
          getIL.Append(Ret());
        }


        if (setIL != null) {
          // setter
          using (var ctx = new MethodContext(asm, setIL.Body.Method, addressGetter: (x) => addressLoader(x, 0))) {
            WeaveNetworkWrap(asm, setIL, ctx, il => il.Append(Instruction.Create(valueOpCode)), wrapInfo);
            //if (cache != null) {
            //  setIL.Append(Ldarg_0());
            //  setIL.Append(Ldarg_1());
            //  setIL.Append(Stfld(cache));
            //}
            setIL.Append(Ret());
          }
        }
      }
      // other value types
      else if (type.IsValueType) {
        var resolvedPropertyType = type.TryResolve();
        if (resolvedPropertyType == null) {
          throw new ILWeaverException($"Can't resolve type for property {property.FullName} with type {property.PropertyType}");
        }

        if (resolvedPropertyType.IsEnum) {
          addressLoader(getIL, 0);
          var underlayingEnumType = resolvedPropertyType.GetEnumUnderlyingType();
          getIL.Append(Ldind(underlayingEnumType));
          getIL.Append(Instruction.Create(OpCodes.Ret));

          addressLoader(setIL, 0);
          setIL.Append(Instruction.Create(valueOpCode));
          setIL.Append(Stind(underlayingEnumType));
          setIL.Append(Instruction.Create(OpCodes.Ret));
        } else if (type.IsQuaternion()) {
          var accuracy = GetFloatAccuracy(property);

          // getter
          var read = asm.ReadWriteUtils.GetMethod("ReadQuaternion");

          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Ldc_R4, accuracy));
          getIL.Append(Instruction.Create(OpCodes.Call, read));
          getIL.Append(Instruction.Create(OpCodes.Ret));

          // setter
          var write = asm.ReadWriteUtils.GetMethod("WriteQuaternion");

          addressLoader(setIL, 0);
          setIL.Append(Instruction.Create(OpCodes.Ldc_R4, accuracy == 0 ? 0 : (1f / accuracy)));
          setIL.Append(Instruction.Create(valueOpCode));
          setIL.Append(Instruction.Create(OpCodes.Call, write));
          setIL.Append(Instruction.Create(OpCodes.Ret));
        } else if (type.IsVector2()) {
          var accuracy = GetFloatAccuracy(property);

          // getter
          var read = asm.ReadWriteUtils.GetMethod("ReadVector2");

          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Ldc_R4, accuracy));
          getIL.Append(Instruction.Create(OpCodes.Call, read));
          getIL.Append(Instruction.Create(OpCodes.Ret));

          // setter
          var write = asm.ReadWriteUtils.GetMethod("WriteVector2");

          addressLoader(setIL, 0);
          setIL.Append(Instruction.Create(OpCodes.Ldc_R4, accuracy == 0 ? 0 : (1f / accuracy)));
          setIL.Append(Instruction.Create(valueOpCode));
          setIL.Append(Instruction.Create(OpCodes.Call, write));
          setIL.Append(Instruction.Create(OpCodes.Ret));
        } else if (type.IsVector3()) {
          var accuracy = GetFloatAccuracy(property);

          // getter
          var read = asm.ReadWriteUtils.GetMethod("ReadVector3");

          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Ldc_R4, accuracy));
          getIL.Append(Instruction.Create(OpCodes.Call, read));
          getIL.Append(Instruction.Create(OpCodes.Ret));

          // setter
          var write = asm.ReadWriteUtils.GetMethod("WriteVector3");

          addressLoader(setIL, 0);
          setIL.Append(Instruction.Create(OpCodes.Ldc_R4, accuracy == 0 ? 0 : (1f / accuracy)));
          setIL.Append(Instruction.Create(valueOpCode));
          setIL.Append(Instruction.Create(OpCodes.Call, write));
          setIL.Append(Instruction.Create(OpCodes.Ret));
        } else if (type.IsNetworkDictionary(out var keyType, out var valType)) {

          if (setIL != null) {
            throw new ILWeaverException($"NetworkDictionary properties can't have setters.");
          }

          var capacity  = GetStaticDictionaryCapacity(property);
          
          var keyInfo = MakeElementReaderWriter(asm, property, keyType);
          var valInfo = MakeElementReaderWriter(asm, property, valType);

          // load address
          keyInfo.InitializeInstance(getIL);
          valInfo.InitializeInstance(getIL);
          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Ldc_I4, capacity));
          keyInfo.LoadInstance(getIL);
          valInfo.LoadInstance(getIL);

          var ctor = asm.CecilAssembly.MainModule.ImportReference(type.Resolve().GetConstructors().First(x => x.Parameters.Count > 1));
          ctor.DeclaringType = ctor.DeclaringType.MakeGenericInstanceType(keyType, valType);

          getIL.Append(Instruction.Create(OpCodes.Newobj, ctor));
          getIL.Append(Instruction.Create(OpCodes.Ret));
          
        } else if (type.IsNetworkList(out var elementType)) {
          if (setIL != null) {
            throw new ILWeaverException($"NetworkList properties can't have setters.");
          }
          
          var listCapacity      = GetStaticListCapacity(property);
          
          var elementInfo = MakeElementReaderWriter(asm, property, elementType);

          elementInfo.InitializeInstance(getIL);
          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Ldc_I4, listCapacity));
          elementInfo.LoadInstance(getIL);
          
          var ctor = asm.CecilAssembly.MainModule.ImportReference(type.Resolve().GetConstructors().First(x => x.Parameters.Count > 1));
          ctor.DeclaringType = ctor.DeclaringType.MakeGenericInstanceType(elementType);

          getIL.Append(Instruction.Create(OpCodes.Newobj, ctor));
          getIL.Append(Instruction.Create(OpCodes.Ret));
          
        } else if (type.IsNetworkArray(out elementType)) {
          if (setIL != null) {
            throw new ILWeaverException($"NetworkArray properties can't have setters.");
          }

          var arrayLength = GetStaticArrayCapacity(property);
          var elementInfo = MakeElementReaderWriter(asm, property, elementType);

          // load address
          elementInfo.InitializeInstance(getIL);
          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Ldc_I4, arrayLength));
          elementInfo.LoadInstance(getIL);

          var ctor = asm.CecilAssembly.MainModule.ImportReference(type.Resolve().GetConstructors().First(x => x.Parameters.Count > 1));
          ctor.DeclaringType = ctor.DeclaringType.MakeGenericInstanceType(elementType);

          getIL.Append(Instruction.Create(OpCodes.Newobj, ctor));
          getIL.Append(Instruction.Create(OpCodes.Ret));
        } else {
          addressLoader(getIL, 0);
          getIL.Append(Instruction.Create(OpCodes.Ldobj, type));
          getIL.Append(Instruction.Create(OpCodes.Ret));

          addressLoader(setIL, 0);
          setIL.Append(Instruction.Create(valueOpCode));
          setIL.Append(Instruction.Create(OpCodes.Stobj, type));
          setIL.Append(Instruction.Create(OpCodes.Ret));
        }
      }
    }

    void RemoveBackingField(PropertyDefinition property) {
      var backing = FindBackingField(property.DeclaringType, property.Name);
      if (backing != null) {
        property.DeclaringType.Fields.Remove(backing);
      }
    }

    (MethodDefinition getter, MethodDefinition setter) PreparePropertyForWeaving(PropertyDefinition property) {
      var getter = property.GetMethod;
      var setter = property.SetMethod;

      // clear getter
      getter.CustomAttributes.Clear();
      getter.Body.Instructions.Clear();

      // clear setter if it exists
      setter?.CustomAttributes?.Clear();
      setter?.Body?.Instructions?.Clear();

      return (getter, setter);
    }

    bool IsWeavableProperty(PropertyDefinition property) {
      return IsWeavableProperty(property, out _);
    }

    struct WeavablePropertyMeta {
      public string DefaultFieldName;
      public FieldDefinition BackingField;
      public bool ReatainIL;
      public string OnChanged;
    } 

    bool IsWeavableProperty(PropertyDefinition property, out WeavablePropertyMeta meta) {
      if (property.TryGetAttribute<NetworkedAttribute>(out var attr) == false) {
        meta = default;
        return false;
      }

      string onChanged;
      attr.TryGetAttributeProperty(nameof(NetworkedAttribute.OnChanged), out onChanged);

      // check getter ... it has to exist
      var getter = property.GetMethod;
      if (getter == null) {
        meta = default;
        return false;
      }

      // check setter ...
      var setter = property.SetMethod;
      if (setter == null) {
        // if it doesn't exist we allow either array or pointer
        if (property.PropertyType.IsByReference == false && property.PropertyType.IsPointer == false && property.PropertyType.IsNetworkArray() == false && property.PropertyType.IsNetworkDictionary() == false && property.PropertyType.IsNetworkList() == false) {
          throw new ILWeaverException($"Simple properties need a setter.");
        }
      }

      // check for backing field ...
      var backing = FindBackingField(property.DeclaringType, property.Name);
      if (backing == null) {
        var il = attr.Properties.FirstOrDefault(x => x.Name == "RetainIL");

        if (il.Argument.Value is bool retainIL && retainIL) {
          meta = new WeavablePropertyMeta() {
            ReatainIL = true,
            OnChanged = onChanged,
          };
          return true;
        }
      }

      meta = new WeavablePropertyMeta() {
        BackingField = backing,
        ReatainIL = false,
        OnChanged = onChanged,
      };

      attr.TryGetAttributeProperty(nameof(NetworkedAttribute.Default), out meta.DefaultFieldName);
      

      return true;
    }

    bool IsRpcCompatibleType(TypeReference property) {
      if (property.IsPointer) {
        return false;
      }

      if (property.IsNetworkArray() || property.IsNetworkList() || property.IsNetworkDictionary()) {
        return false;
      }

      if (property.IsString()) {
        return true;
      }

      if (property.IsValueType) {
        return true;
      }

      if (TryGetNetworkWrapperType(property, out var wrapInfo)) {
        if (wrapInfo.MaxRawByteCount > 0) {
          return true;
        } else {
          return IsRpcCompatibleType(wrapInfo.WrapperType);
        }
      }

      return false;
    }

    void WeaveInput(ILWeaverAssembly asm, TypeDefinition type) {
      if (type.TryGetAttribute<NetworkInputWeavedAttribute>(out var attribute)) {
        if (_typeData.ContainsKey(type.FullName) == false) {
          _typeData.Add(type.FullName, new TypeMetaData {
            WordCount = (int)attribute.ConstructorArguments[0].Value,
            Definition = type,
            Reference = type
          });
        }

        return;
      }

      using (Log.ScopeInput(type)) {

        int wordCount = WeaveStructInner(asm, type);

        // add new attribute
        type.AddAttribute<NetworkInputWeavedAttribute, int>(asm, wordCount);

        // track type data
        _typeData.Add(type.FullName, new TypeMetaData {
          WordCount = wordCount,
          Definition = type,
          Reference = type
        });
      }
    }

    

    MethodReference FindMethodInParent(ILWeaverAssembly asm, TypeDefinition type, string name, string stopAtType = null, int? argCount = null) {
      type = type.BaseType.Resolve();

      while (type != null) {
        if (type.Name == stopAtType || type.FullName == "System.Object") {
          return null;
        }

        var method = type.Methods.FirstOrDefault(x => x.Name == name && ((argCount == null) || (x.Parameters.Count == argCount.Value)));
        if (method != null) {
          return asm.CecilAssembly.MainModule.ImportReference(method);
        }

        type = type.BaseType.Resolve();
      }

      return null;
    }

    string InvokerMethodName(string method, Dictionary<string, int> nameCache) {
      nameCache.TryGetValue(method, out var count);
      nameCache[method] = ++count;
      return $"{method}@Invoker{(count == 1 ? "" : count.ToString())}";
    }

    bool HasRpcPrefixOrSuffix(MethodDefinition def) {
      return def.Name.StartsWith("rpc", StringComparison.OrdinalIgnoreCase) || def.Name.EndsWith("rpc", StringComparison.OrdinalIgnoreCase);
    }

    void WeaveRpcs(ILWeaverAssembly asm, TypeDefinition type, bool allowInstanceRpcs = true) {
      if (type.HasGenericParameters) {
        return;
      }

      // rpc list
      var rpcs = new List<(MethodDefinition, CustomAttribute)>();


      bool hasStaticRpc = false;

      foreach (var rpc in type.Methods) {
        if (rpc.TryGetAttribute<RpcAttribute>(out var attr)) {

          if (HasRpcPrefixOrSuffix(rpc) == false) {
            Log.Warn($"{rpc.DeclaringType}.{rpc.Name} name does not start or end with the \"Rpc\" prefix or suffix. Starting from Beta this will result in an error.");
          }

          if (rpc.IsStatic && rpc.Parameters.FirstOrDefault()?.ParameterType.FullName != asm.NetworkRunner.Reference.FullName) {
            throw new ILWeaverException($"{rpc}: Static RPC needs {nameof(NetworkRunner)} as the first parameter");
          }

          hasStaticRpc |= rpc.IsStatic;

          if (!allowInstanceRpcs && !rpc.IsStatic) {
            throw new ILWeaverException($"{rpc}: Instance RPCs not allowed for this type");
          }

          foreach (var parameter in rpc.Parameters) {
            if (rpc.IsStatic && parameter == rpc.Parameters[0]) {
              continue;
            }

            if (IsInvokeOnlyParameter(parameter)) {
              continue;
            }

            var parameterType = parameter.ParameterType.IsArray ? parameter.ParameterType.GetElementType() : parameter.ParameterType;

            if (IsRpcCompatibleType(parameterType) == false) {
              throw new ILWeaverException($"{rpc}: parameter {parameter.Name} is not Rpc-compatible.");
            }
          }

          if (!rpc.ReturnType.Is(asm.RpcInvokeInfo) && !rpc.ReturnType.IsVoid()) {
            throw new ILWeaverException($"{rpc}: RPCs can't return a value.");
          }

          rpcs.Add((rpc, attr));
        }
      }

      if (!rpcs.Any()) {
        return;
      }

      int instanceRpcKeys = GetInstanceRpcCount(type.BaseType);

      Dictionary<string, int> invokerNameCounter = new Dictionary<string, int>();

      foreach (var (rpc, attr) in rpcs) {
        int sources;
        int targets;

        if (attr.ConstructorArguments.Count == 2) {
          sources = attr.GetAttributeArgument<int>(0);
          targets = attr.GetAttributeArgument<int>(1);
        } else {
          sources = AuthorityMasks.ALL;
          targets = AuthorityMasks.ALL;
        }

        ParameterDefinition rpcTargetParameter = rpc.Parameters.SingleOrDefault(x => x.HasAttribute<RpcTargetAttribute>());
        if (rpcTargetParameter != null && !rpcTargetParameter.ParameterType.Is<PlayerRef>()) {
          throw new ILWeaverException($"{rpcTargetParameter}: {nameof(RpcTargetAttribute)} can only be used for {nameof(PlayerRef)} type argument");
        }

        attr.TryGetAttributeProperty<bool>(nameof(RpcAttribute.InvokeLocal), out var invokeLocal, defaultValue: true);
        attr.TryGetAttributeProperty<bool>(nameof(RpcAttribute.InvokeResim), out var invokeResim);
        attr.TryGetAttributeProperty<RpcChannel>(nameof(RpcAttribute.Channel), out var channel);
        attr.TryGetAttributeProperty<bool>(nameof(RpcAttribute.TickAligned), out var tickAligned, defaultValue: true);
        attr.TryGetAttributeProperty<RpcHostMode>(nameof(RpcAttribute.HostMode), out var hostMode);

        // rpc key
        int instanceRpcKey = -1;
        var returnsRpcInvokeInfo = rpc.ReturnType.Is(asm.RpcInvokeInfo);



        using (var ctx = new RpcMethodContext(asm, rpc, rpc.IsStatic)) {

          // local variables
          ctx.DataVariable = new VariableDefinition(asm.Import(typeof(byte)).MakePointerType());
          ctx.OffsetVariable = new VariableDefinition(asm.Import(typeof(int)));
          var message = new VariableDefinition(asm.SimulationMessage.Reference.MakePointerType());
          VariableDefinition localAuthorityMask = null;

          rpc.Body.Variables.Add(ctx.DataVariable);
          rpc.Body.Variables.Add(ctx.OffsetVariable);
          rpc.Body.Variables.Add(message);
          rpc.Body.InitLocals = true;

          // get il processes and our jump instruction
          var il = rpc.Body.GetILProcessor();
          var jmp = Nop();
          var inv = Nop();
          var prepareInv = Nop();

          Instruction targetedInvokeLocal = null;


          // instructions for our branch
          var ins = new List<Instruction>();

          if (returnsRpcInvokeInfo) {
            // find local variable that's used for return(default);
            ctx.RpcInvokeInfoVariable = new VariableDefinition(asm.RpcInvokeInfo);
            rpc.Body.Variables.Add(ctx.RpcInvokeInfoVariable);
            ins.Add(Ldloca(ctx.RpcInvokeInfoVariable));
            ins.Add(Initobj(ctx.RpcInvokeInfoVariable.VariableType));

            // fix each ret
            var instructions = il.Body.Instructions;
            for (int i = 0; i < instructions.Count; ++i) {
              var instruction = instructions[i];
              if (instruction.OpCode == OpCodes.Ret) {
                if (instructions[i - 1].IsLdlocWithIndex(out _)) {
                  // replace indexed load
                  instructions[i - 1].OpCode = OpCodes.Ldloc;
                  instructions[i - 1].Operand = ctx.RpcInvokeInfoVariable;
                } else if (instructions[i - 1].OpCode == OpCodes.Ldloc) {
                  // replace named load
                  instructions[i - 1].Operand = ctx.RpcInvokeInfoVariable;
                } else {
                  throw new ILWeaverException($"{rpc}: return pattern of {nameof(RpcInvokeInfo)} not recognised at {instruction}. Context: {string.Join("\n", instructions)}");
                }
              }
            }
          }

          if (rpc.IsStatic) {
            ins.Add(Ldsfld(asm.NetworkBehaviourUtils.GetField(nameof(NetworkBehaviourUtils.InvokeRpc))));
            ins.Add(Brfalse(jmp));
            ins.Add(Ldc_I4(0));
            ins.Add(Stsfld(asm.NetworkBehaviourUtils.GetField(nameof(NetworkBehaviourUtils.InvokeRpc))));
          } else {
            ins.Add(Ldarg_0());
            ins.Add(Ldfld(asm.NetworkedBehaviour.GetField(nameof(NetworkBehaviour.InvokeRpc))));
            ins.Add(Brfalse(jmp));
            ins.Add(Ldarg_0());
            ins.Add(Ldc_I4(0));
            ins.Add(Stfld(asm.NetworkedBehaviour.GetField(nameof(NetworkBehaviour.InvokeRpc))));
          }
          ins.Add(inv);


          // insert instruction into method body
          var prev = rpc.Body.Instructions[0]; //.OpCode == OpCodes.Nop ? rpc.Body.Instructions[1] :  rpc.Body.Instructions[0];

          for (int i = ins.Count - 1; i >= 0; --i) {
            il.InsertBefore(prev, ins[i]);
            prev = ins[i];
          }

          // jump target
          il.Append(jmp);

          

          var returnInstructions = returnsRpcInvokeInfo
            ? new[] { Ldloc(ctx.RpcInvokeInfoVariable), Ret() }
            : new[] { Ret() };

          var ret = returnInstructions.First();

          // check if runner's ok
          if (rpc.IsStatic) {
            il.AppendMacro(ctx.LoadRunner());
            var checkDone = Nop();
            il.Append(Brtrue_S(checkDone));
            il.Append(Ldstr(rpc.Parameters[0].Name));
            il.Append(Newobj(typeof(ArgumentNullException).GetConstructor(asm, 1)));
            il.Append(Throw());
            il.Append(checkDone);
          } else {
            il.Append(Ldarg_0());
            il.Append(Call(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.ThrowIfBehaviourNotInitialized))));
          }

          il.AppendMacro(ctx.SetRpcInvokeInfoStatus(!invokeLocal, RpcLocalInvokeResult.NotInvokableLocally));

          // if we shouldn't invoke during resim
          if (invokeResim == false) {
            var checkDone = Nop();

            il.AppendMacro(ctx.LoadRunner());

            il.Append(Call(asm.NetworkRunner.GetProperty("Stage")));
            il.Append(Ldc_I4((int)SimulationStages.Resimulate));
            il.Append(Bne_Un_S(checkDone));

            il.AppendMacro(ctx.SetRpcInvokeInfoStatus(invokeLocal, RpcLocalInvokeResult.NotInvokableDuringResim));
            il.AppendMacro(ctx.SetRpcInvokeInfoStatus(RpcSendCullResult.NotInvokableDuringResim));
            il.Append(Br(ret));

            il.Append(checkDone);
          }

          if (!rpc.IsStatic) {
            localAuthorityMask = new VariableDefinition(asm.Import(typeof(int)));
            rpc.Body.Variables.Add(localAuthorityMask);
            il.Append(Ldarg_0());
            il.Append(Ldfld(asm.NetworkedBehaviour.GetField(OBJECT_FIELD_NAME)));
            il.Append(Call(asm.NetworkedObject.GetMethod(nameof(NetworkObject.GetLocalAuthorityMask))));
            il.Append(Stloc(localAuthorityMask));
          }

          // check if target is reachable or not
          if (rpcTargetParameter != null) {
            il.AppendMacro(ctx.LoadRunner());

            il.Append(Ldarg(rpcTargetParameter));
            il.Append(Call(asm.NetworkRunner.GetMethod(nameof(NetworkRunner.GetRpcTargetStatus))));
            il.Append(Dup());

            // check for being unreachable
            {
              var done = Nop();
              il.Append(Ldc_I4((int)RpcTargetStatus.Unreachable));
              il.Append(Bne_Un_S(done));
              il.Append(Ldarg(rpcTargetParameter));
              il.Append(Ldstr(rpc.ToString()));
              il.Append(Call(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.NotifyRpcTargetUnreachable))));
              il.Append(Pop()); // pop the GetRpcTargetStatus

              il.AppendMacro(ctx.SetRpcInvokeInfoStatus(invokeLocal, RpcLocalInvokeResult.TagetPlayerIsNotLocal));
              il.AppendMacro(ctx.SetRpcInvokeInfoStatus(RpcSendCullResult.TargetPlayerUnreachable));
              il.Append(Br(ret));

              il.Append(done);
            }

            // check for self
            {
              il.Append(Ldc_I4((int)RpcTargetStatus.Self));
              if (invokeLocal) {
                // straight to the invoke; this will prohibit any sending
                Log.Assert(targetedInvokeLocal == null);
                targetedInvokeLocal = Nop();
                il.Append(Beq(targetedInvokeLocal));
                il.AppendMacro(ctx.SetRpcInvokeInfoStatus(true, RpcLocalInvokeResult.TagetPlayerIsNotLocal));
              } else {
                // will never get called
                var checkDone = Nop();
                il.Append(Bne_Un_S(checkDone));

                if (NetworkRunner.BuildType == NetworkRunner.BuildTypes.Debug) {
                  il.Append(Ldarg(rpcTargetParameter));
                  il.Append(Ldstr(rpc.ToString()));
                  il.Append(Call(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.NotifyLocalTargetedRpcCulled))));
                }

                il.AppendMacro(ctx.SetRpcInvokeInfoStatus(RpcSendCullResult.TargetPlayerIsLocalButRpcIsNotInvokableLocally));
                il.Append(Br(ret));

                il.Append(checkDone);
              }
            }
          }

          // check if sender flags make sense
          if (!rpc.IsStatic) {
            var checkDone = Nop();

            il.Append(Ldloc(localAuthorityMask));
            il.Append(Ldc_I4(sources));
            il.Append(And());
            il.Append(Brtrue_S(checkDone));

            // source is not valid, notify
            il.Append(Ldstr(rpc.ToString()));
            il.Append(Ldarg_0());
            il.Append(Ldfld(asm.NetworkedBehaviour.GetField(OBJECT_FIELD_NAME)));
            il.Append(Ldc_I4(sources));
            il.Append(Call(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.NotifyLocalSimulationNotAllowedToSendRpc))));

            il.AppendMacro(ctx.SetRpcInvokeInfoStatus(invokeLocal, RpcLocalInvokeResult.InsufficientSourceAuthority));
            il.AppendMacro(ctx.SetRpcInvokeInfoStatus(RpcSendCullResult.InsufficientSourceAuthority));

            il.Append(Br(ret));

            il.Append(checkDone);

            if (invokeLocal) {
              // how about the target? does it match only the local client?
              if (targets != 0 && (targets & AuthorityMasks.PROXY) == 0) {
                il.Append(Ldloc(localAuthorityMask));
                il.Append(Ldc_I4(targets));
                il.Append(And());
                il.Append(Ldc_I4(targets));
                il.Append(Beq(prepareInv));
              }
            }
          }

          // check if sending makes sense at all
          var afterSend = Nop();

          // if not targeted (already handled earlier) check if it can be sent at all
          if (rpcTargetParameter == null) {
            var checkDone = Nop();
            il.AppendMacro(ctx.LoadRunner());
            il.Append(Call(asm.NetworkRunner.GetMethod(nameof(NetworkRunner.HasAnyActiveConnections))));
            il.Append(Brtrue(checkDone));
            il.AppendMacro(ctx.SetRpcInvokeInfoStatus(RpcSendCullResult.NoActiveConnections));
            il.Append(Br(afterSend));
            il.Append(checkDone);
          }

          // create simulation message
          il.AppendMacro(ctx.LoadRunner());
          il.Append(Call(asm.NetworkRunner.GetProperty(nameof(NetworkRunner.Simulation))));
          il.Append(Ldc_I4(RpcHeader.SIZE));

          for (int i = 0; i < rpc.Parameters.Count; ++i) {
            var para = rpc.Parameters[i];

            if (rpc.IsStatic && i == 0) {
              Log.Assert(para.ParameterType.IsSame<NetworkRunner>());
              continue;
            }

            if (IsInvokeOnlyParameter(para)) {
              continue;
            }
            if (para == rpcTargetParameter) {
              continue;
            }

            if (para.ParameterType.IsString()) {
              il.Append(Ldarg(para));
              il.Append(Call(asm.Native.GetMethod(nameof(Native.GetLengthPrefixedUTF8ByteCount))));
              il.AppendMacro(AlignToWordSize());
            } else if (para.ParameterType.IsArray) {
              WeaveArrayByteSize(asm, il, para);
            } else {
              var size = GetByteCount(asm, para.ParameterType);
              il.Append(Ldc_I4(size));
            }
            il.Append(Add());
          }

          il.Append(Call(asm.SimulationMessage.GetMethod(nameof(SimulationMessage.Allocate), 2)));
          il.Append(Stloc(message));

          // get data for messages
          il.Append(Ldloc(message));
          il.Append(Call(asm.SimulationMessage.GetMethod(nameof(SimulationMessage.GetData), 1)));
          il.Append(Stloc(ctx.DataVariable));

          // create RpcHeader
          // il.Append(Ldloc(data));

          if (rpc.IsStatic) {
            il.Append(Ldstr(rpc.ToString()));
            il.Append(Call(asm.Import(typeof(NetworkBehaviourUtils).GetMethod(nameof(NetworkBehaviourUtils.GetRpcStaticIndexOrThrow)))));
            il.Append(Call(asm.RpcHeader.GetMethod(nameof(RpcHeader.Create), 1)));
          } else {
            il.Append(Ldarg_0());
            il.Append(Ldfld(asm.NetworkedBehaviour.GetField(OBJECT_FIELD_NAME)));
            il.Append(Ldfld(asm.NetworkedObject.GetField(nameof(NetworkObject.Id))));

            il.Append(Ldarg_0());
            il.Append(Ldfld(asm.NetworkedBehaviour.GetField(nameof(NetworkBehaviour.ObjectIndex))));

            instanceRpcKey = ++instanceRpcKeys;
            il.Append(Ldc_I4(instanceRpcKey));
            il.Append(Call(asm.RpcHeader.GetMethod(nameof(RpcHeader.Create), 3)));
          }

          il.Append(Ldloc(ctx.DataVariable));
          il.Append(Call(asm.RpcHeader.GetMethod(nameof(RpcHeader.Write))));
          il.AppendMacro(AlignToWordSize());
          //il.Append(Stobj(asm.RpcHeader.Reference));

          //il.Append(Ldc_I4(RpcHeader.SIZE));
          il.Append(Stloc(ctx.OffsetVariable));

          // write parameters
          for (int i = 0; i < rpc.Parameters.Count; ++i) {
            var para = rpc.Parameters[i];

            if (rpc.IsStatic && i == 0) {
              continue;
            }
            if (IsInvokeOnlyParameter(para)) {
              continue;
            }
            if (para == rpcTargetParameter) {
              continue;
            }
            if (para.ParameterType.IsString()) {
              using (ctx.AddOffsetScope(il)) { 
                il.AppendMacro(ctx.LoadAddress());
                il.Append(Ldarg(para));
                il.Append(Call(asm.Native.GetMethod(nameof(Native.WriteLengthPrefixedUTF8))));
                il.AppendMacro(AlignToWordSize());
              };
            } else if (para.ParameterType.IsArray) {
              WeaveRpcArrayInput(asm, ctx, il, para);
            } else {
              if (!para.ParameterType.IsPrimitive && TryGetNetworkWrapperType(para.ParameterType, out var wrapInfo)) {
                WeaveNetworkWrap(asm, il, ctx, il => il.Append(Ldarg(para)), wrapInfo);
              } else {
                il.AppendMacro(ctx.LoadAddress());
                il.Append(Ldarg(para));
                il.Append(Stind_or_Stobj(para.ParameterType));
                il.AppendMacro(ctx.AddOffset(GetByteCount(asm, para.ParameterType)));
              }
            }
          }

          // update message offset
          il.Append(Ldloc(message));
          il.Append(Ldflda(asm.SimulationMessage.GetField(nameof(SimulationMessage.Offset))));
          il.Append(Ldloc(ctx.OffsetVariable));
          il.Append(Ldc_I4(8));
          il.Append(Mul());
          il.Append(Stind_I4());

          // send message

          il.AppendMacro(ctx.LoadRunner());

          if (rpcTargetParameter != null) {
            il.Append(Ldloc(message));
            il.Append(Ldarg(rpcTargetParameter));
            il.Append(Call(asm.SimulationMessage.GetMethod(nameof(SimulationMessage.SetTarget))));
          }

          if (channel == RpcChannel.Unreliable) {
            il.Append(Ldloc(message));
            il.Append(Call(asm.SimulationMessage.GetMethod(nameof(SimulationMessage.SetUnreliable))));
          }

          if (!tickAligned) {
            il.Append(Ldloc(message));
            il.Append(Call(asm.SimulationMessage.GetMethod(nameof(SimulationMessage.SetNotTickAligned))));
          }

          if (rpc.IsStatic) {
            il.Append(Ldloc(message));
            il.Append(Call(asm.SimulationMessage.GetMethod(nameof(SimulationMessage.SetStatic))));
          }

          // send the rpc
          il.Append(Ldloc(message));
          
          if (ctx.RpcInvokeInfoVariable != null) {
            il.Append(Ldloca(ctx.RpcInvokeInfoVariable));
            il.Append(Ldflda(asm.RpcInvokeInfo.GetField(nameof(RpcInvokeInfo.SendResult))));
            il.Append(Call(asm.NetworkRunner.GetMethod(nameof(NetworkRunner.SendRpc), 2)));
          } else {
            il.Append(Call(asm.NetworkRunner.GetMethod(nameof(NetworkRunner.SendRpc), 1)));
          }

          il.AppendMacro(ctx.SetRpcInvokeInfoStatus(RpcSendCullResult.NotCulled));

          il.Append(afterSend);

          // .. hmm
          if (invokeLocal) {

            if (targetedInvokeLocal != null) {
              il.Append(Br(ret));
              il.Append(targetedInvokeLocal);
            }

            if (!rpc.IsStatic) {
              var checkDone = Nop();
              il.Append(Ldloc(localAuthorityMask));
              il.Append(Ldc_I4(targets));
              il.Append(And());
              il.Append(Brtrue_S(checkDone));

              il.AppendMacro(ctx.SetRpcInvokeInfoStatus(true, RpcLocalInvokeResult.InsufficientTargetAuthority));

              il.Append(Br(ret));

              il.Append(checkDone);
            }

            il.Append(prepareInv);

            foreach (var param in rpc.Parameters) {
              if (param.ParameterType.IsSame<RpcInfo>()) {
                // need to fill it now
                il.AppendMacro(ctx.LoadRunner());
                il.Append(Ldc_I4((int)channel));
                il.Append(Ldc_I4((int)hostMode));
                il.Append(Call(asm.RpcInfo.GetMethod(nameof(RpcInfo.FromLocal))));
                il.Append(Starg_S(param));
              }
            }

            il.AppendMacro(ctx.SetRpcInvokeInfoStatus(true, RpcLocalInvokeResult.Invoked));

            // invoke
            il.Append(Br(inv));
          }

          foreach (var instruction in returnInstructions) {
            il.Append(instruction);
          }
        }

        var invoker = new MethodDefinition(InvokerMethodName(rpc.Name, invokerNameCounter), MethodAttributes.Family | MethodAttributes.Static, asm.Import(typeof(void)));
        using (var ctx = new RpcMethodContext(asm, invoker, rpc.IsStatic)) {

          // create invoker delegate
          if (rpc.IsStatic) {
            var runner = new ParameterDefinition("runner", ParameterAttributes.None, asm.NetworkRunner.Reference);
            invoker.Parameters.Add(runner);
          } else {
            var behaviour = new ParameterDefinition("behaviour", ParameterAttributes.None, asm.NetworkedBehaviour.Reference);
            invoker.Parameters.Add(behaviour);
          }
          var message = new ParameterDefinition("message", ParameterAttributes.None, asm.SimulationMessage.Reference.MakePointerType());
          invoker.Parameters.Add(message);

          // add attribute
          if (rpc.IsStatic) {
            Log.Assert(instanceRpcKey < 0);
            invoker.AddAttribute<NetworkRpcStaticWeavedInvokerAttribute, string>(asm, rpc.ToString());
          } else {
            Log.Assert(instanceRpcKey >= 0);
            invoker.AddAttribute<NetworkRpcWeavedInvokerAttribute, int, int, int>(asm, instanceRpcKey, sources, targets);
          }

          // put on type
          type.Methods.Add(invoker);

          // local variables
          ctx.DataVariable = new VariableDefinition(asm.Import(typeof(byte)).MakePointerType());
          ctx.OffsetVariable = new VariableDefinition(asm.Import(typeof(int)));
          var parameters = new VariableDefinition[rpc.Parameters.Count];

          for (int i = 0; i < parameters.Length; ++i) {
            invoker.Body.Variables.Add(parameters[i] = new VariableDefinition(rpc.Parameters[i].ParameterType));
          }

          invoker.Body.Variables.Add(ctx.DataVariable);
          invoker.Body.Variables.Add(ctx.OffsetVariable);
          invoker.Body.InitLocals = true;

          var il = invoker.Body.GetILProcessor();

          // grab data from message and store in local
          il.Append(Ldarg_1());
          il.Append(Call(asm.SimulationMessage.GetMethod(nameof(SimulationMessage.GetData), 1)));
          il.Append(Stloc(ctx.DataVariable));

          il.Append(Ldloc(ctx.DataVariable));
          il.Append(Call(asm.RpcHeader.GetMethod(nameof(RpcHeader.ReadSize))));
          il.AppendMacro(AlignToWordSize());
          il.Append(Stloc(ctx.OffsetVariable));

          for (int i = 0; i < parameters.Length; ++i) {
            var para = parameters[i];

            if (rpc.IsStatic && i == 0) {
              il.Append(Ldarg_0());
              il.Append(Stloc(para));
              continue;
            }

            if (rpcTargetParameter == rpc.Parameters[i]) {
              il.Append(Ldarg_1());
              il.Append(Ldfld(asm.SimulationMessage.GetField(nameof(SimulationMessage.Target))));
              il.Append(Stloc(para));
            } else if (para.VariableType.IsString()) {

              using (ctx.AddOffsetScope(il)) { 
                il.AppendMacro(ctx.LoadAddress());
                il.Append(Ldloca(para));
                il.Append(Call(asm.Native.GetMethod(nameof(Native.ReadLengthPrefixedUTF8))));
                il.AppendMacro(AlignToWordSize());
              };

            } else if (para.VariableType.IsSame<RpcInfo>()) {
              il.AppendMacro(ctx.LoadRunner());
              il.Append(Ldarg_1());
              il.Append(Ldc_I4((int)hostMode));
              il.Append(Call(asm.RpcInfo.GetMethod(nameof(RpcInfo.FromMessage))));
              il.Append(Stloc(para));

            } else if (para.VariableType.IsArray) {
              WeaveRpcArrayInvoke(asm, ctx, il, para);

            } else {
              if (!para.VariableType.IsPrimitive && TryGetNetworkWrapperType(para.VariableType, out var wrapInfo)) {
                WeaveNetworkUnwrap(asm, il, ctx, wrapInfo, para.VariableType, storeResult: il => il.Append(Stloc(para)));
              } else {
                il.AppendMacro(ctx.LoadAddress());
                il.Append(Ldind_or_Ldobj(para.VariableType));
                il.Append(Stloc(para));
                il.AppendMacro(ctx.AddOffset(GetByteCount(asm, para.VariableType)));
              }
            }
          }

          if (rpc.IsStatic) {
            il.Append(Ldc_I4(1));
            il.Append(Stsfld(asm.NetworkBehaviourUtils.GetField(nameof(NetworkBehaviour.InvokeRpc))));
          } else {
            il.Append(Ldarg_0());
            il.Append(Ldc_I4(1));
            il.Append(Stfld(asm.NetworkedBehaviour.GetField(nameof(NetworkBehaviour.InvokeRpc))));
          }

          if (!rpc.IsStatic) {
            il.Append(Ldarg_0());
            il.Append(Instruction.Create(OpCodes.Castclass, rpc.DeclaringType));
          }

          for (int i = 0; i < parameters.Length; ++i) {
            il.Append(Ldloc(parameters[i]));
          }
          il.Append(Call(rpc));
          if (returnsRpcInvokeInfo) {
            il.Append(Pop());
          }
          il.Append(Ret());
        }
      }

      {
        Log.Assert(_rpcCount.TryGetValue(type.FullName, out int count) == false || count == instanceRpcKeys);
        _rpcCount[type.FullName] = instanceRpcKeys;
      }
    }

    private int GetInstanceRpcCount(TypeReference type) {
      if (_rpcCount.TryGetValue(type.FullName, out int result)) {
        return result;
      }

      result = 0;

      var typeDef = type.TryResolve();
      if (typeDef != null) {

        if (typeDef.BaseType != null) {
          result += GetInstanceRpcCount(typeDef.BaseType);
        }

        result += typeDef.GetMethods()
          .Where(x => !x.IsStatic)
          .Where(x => x.HasAttribute<RpcAttribute>())
          .Count();
      }

      _rpcCount.Add(type.FullName, result);
      return result;
    }

    private bool IsInvokeOnlyParameter(ParameterDefinition para) {
      if (para.ParameterType.IsSame<RpcInfo>()) {
        return true;
      }
      return false;
    }



    void WeaveArrayByteSize(ILWeaverAssembly asm, ILProcessor il, ParameterDefinition para) {

      int size;

      var elementType = para.ParameterType.GetElementType();
      if (elementType.IsPrimitive) {
        size = elementType.GetPrimitiveSize();
      } else if (TryGetNetworkWrapperType(elementType, out var wrapInfo)) {
        size = GetByteCount(asm, wrapInfo);
      } else {
        size = GetByteCount(asm, elementType);
      }

      // array length
      il.Append(Ldarg(para));
      il.Append(Ldlen());
      il.Append(Conv_I4());

      il.Append(Ldc_I4(size));
      il.Append(Mul());

      if (elementType.IsPrimitive && (size % Allocator.REPLICATE_WORD_SIZE) != 0) {
        // need to align to word count boundaries
        il.AppendMacro(AlignToWordSize());
      }

      // store the length
      il.Append(Ldc_I4(sizeof(Int32)));
      il.Append(Add());
    }

    void WeaveRpcArrayInvoke(ILWeaverAssembly asm, RpcMethodContext ctx, ILProcessor il, VariableDefinition para) {
      var elementType = para.VariableType.GetElementType();

      var intType = asm.Import(typeof(Int32));


      // alloc result array
      il.AppendMacro(ctx.LoadAddress());
      il.Append(Ldind(intType));
      il.Append(Instruction.Create(OpCodes.Newarr, elementType));
      il.Append(Stloc(para));

      il.AppendMacro(ctx.AddOffset(sizeof(Int32)));

      if (elementType.IsPrimitive) {
        using (ctx.AddOffsetScope(il)) { 
          // dst
          il.Append(Ldloc(para));

          // src
          il.AppendMacro(ctx.LoadAddress());

          var memCpy = new GenericInstanceMethod(asm.Native.GetMethod(nameof(Native.CopyToArray), 2));
          memCpy.GenericArguments.Add(elementType);
          il.Append(Call(memCpy));

          if (elementType.IsPrimitive && (elementType.GetPrimitiveSize() % Allocator.REPLICATE_WORD_SIZE) != 0) {
            // need to align to word count boundaries
            il.AppendMacro(AlignToWordSize());
          }
        };
      } else {

        var arrayIndex = ctx.GetOrCreateVariable("ArrayIndex", asm.Import(typeof(int)));
        var exitCondition = Ldloc(arrayIndex);

        il.Append(Ldc_I4(0));
        il.Append(Stloc(arrayIndex));
        il.Append(Br_S(exitCondition));

        // prepare store
        var loopBody = il.AppendReturn(Nop());

        if (TryGetNetworkWrapperType(elementType, out var wrapInfo)) {

          WeaveNetworkUnwrap(asm, il, ctx, wrapInfo, elementType,
            prepareStore: il => {
              il.Append(Ldloc(para));
              il.Append(Ldloc(arrayIndex));
            },
            storeResult: il => {
              il.Append(Stelem(elementType));
            });

        } else {

          il.Append(Ldloc(para));
          il.Append(Ldloc(arrayIndex));

          il.AppendMacro(ctx.LoadAddress());
          il.Append(Ldind_or_Ldobj(elementType));
          il.Append(Stelem(elementType));

          il.AppendMacro(ctx.AddOffset(GetByteCount(asm, elementType)));
        }

        // increase index
        il.Append(Ldloc(arrayIndex));
        il.Append(Ldc_I4(1));
        il.Append(Add());
        il.Append(Stloc(arrayIndex));

        // exit condition
        il.Append(exitCondition);
        il.Append(Ldloc(para));
        il.Append(Ldlen());
        il.Append(Conv_I4());
        il.Append(Blt_S(loopBody));
      }
    }

    void WeaveRpcArrayInput(ILWeaverAssembly asm, RpcMethodContext ctx, ILProcessor il, ParameterDefinition para) {
      var elementType = para.ParameterType.GetElementType();

      // store the array size
      il.AppendMacro(ctx.LoadAddress());

      // array length
      il.Append(Ldarg(para));
      il.Append(Ldlen());
      il.Append(Conv_I4());

      il.Append(Stind_I4());

      il.AppendMacro(ctx.AddOffset(sizeof(Int32)));

      if (elementType.IsPrimitive) {
        using (ctx.AddOffsetScope(il)) { 
          // dst
          il.AppendMacro(ctx.LoadAddress());

          // src
          il.Append(Ldarg(para));
          var memCpy = new GenericInstanceMethod(asm.Native.GetMethod(nameof(Native.CopyFromArray), 2));
          memCpy.GenericArguments.Add(elementType);
          il.Append(Call(memCpy));

          if (elementType.IsPrimitive && (elementType.GetPrimitiveSize() % Allocator.REPLICATE_WORD_SIZE) != 0) {
            il.AppendMacro(AlignToWordSize());
          }
        };
      } else {

        var arrayIndex = ctx.GetOrCreateVariable("arrayIndex", asm.Import(typeof(int)));

        var exitCondition = Ldloc(arrayIndex);

        il.Append(Ldc_I4(0));
        il.Append(Stloc(arrayIndex));
        il.Append(Br_S(exitCondition));

        var loopBody = il.AppendReturn(Nop());


        if (TryGetNetworkWrapperType(elementType, out var wrapInfo)) {

          WeaveNetworkWrap(asm, il, ctx, il => {
            il.Append(Ldarg(para));
            il.Append(Ldloc(arrayIndex));
            il.Append(Ldelem(elementType));
          }, wrapInfo);

        } else {
          // get array elem
          il.AppendMacro(ctx.LoadAddress());

          il.Append(Ldarg(para));
          il.Append(Ldloc(arrayIndex));
          il.Append(Ldelem(elementType));
          il.Append(Stind_or_Stobj(elementType));
          il.AppendMacro(ctx.AddOffset(GetByteCount(asm, elementType)));
        }

        // increase index
        il.Append(Ldloc(arrayIndex));
        il.Append(Ldc_I4(1));
        il.Append(Add());
        il.Append(Stloc(arrayIndex));

        // exit condition
        il.Append(exitCondition);
        il.Append(Ldarg(para));
        il.Append(Ldlen());
        il.Append(Conv_I4());
        il.Append(Blt_S(loopBody));

      }
    }

    void WeaveNetworkWrap(ILWeaverAssembly asm, ILProcessor il, MethodContext ctx, Action<ILProcessor> emitGetValue, WrapInfo wrapInfo) {

      if (!wrapInfo.IsRaw) {
        il.AppendMacro(ctx.LoadAddress());
      }

      il.AppendMacro(ctx.LoadRunner());
      emitGetValue(il);

      if (wrapInfo.IsRaw) {
        il.AppendMacro(ctx.LoadAddress());
      }

      il.Append(Call(ctx.ImportReference(wrapInfo.WrapMethod)));

      if (wrapInfo.IsRaw) {
        // read bytes are on top of the stack
        il.Append(Ldc_I4(wrapInfo.MaxRawByteCount));
        var validateMethod = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.VerifyRawNetworkWrap)));
        validateMethod.GenericArguments.Add(ctx.ImportReference(wrapInfo.Type));
        il.Append(Call(validateMethod));

        if (ctx.HasOffset) {
          il.AppendMacro(AlignToWordSize());
          il.AppendMacro(ctx.AddOffset());
        } else {
          il.Append(Pop());
        }

      } else {
        var type = ctx.ImportReference(wrapInfo.WrapperType.GetElementType());
        il.Append(Stind_or_Stobj(type));
        
        if (ctx.HasOffset) {
          il.AppendMacro(ctx.AddOffset(GetByteCount(asm, type)));
        }
      }
    }

    void WeaveNetworkUnwrap(ILWeaverAssembly asm, ILProcessor il, MethodContext ctx, WrapInfo wrapInfo, TypeReference resultType, FieldDefinition previousValue = null, Action<ILProcessor> prepareStore = null, Action<ILProcessor> storeResult = null) {
      if (resultType == null) {
        throw new ArgumentNullException(nameof(resultType));
      }

      var wrapperType = wrapInfo.UnwrapMethod.Parameters[1].ParameterType;
      Log.Assert(!wrapperType.IsByReference);

      var typeToLoad = ctx.ImportReference(wrapperType);

      if (wrapInfo.IsRaw || wrapInfo.UnwrapByRef) {
        il.AppendMacro(ctx.LoadRunner());
        il.AppendMacro(ctx.LoadAddress());
        if (!wrapInfo.IsRaw) {
          il.Append(Ldind_or_Ldobj(typeToLoad));
        }

        VariableDefinition byRefTempVariable = null;
        if (previousValue == null) {
          byRefTempVariable = ctx.GetOrCreateVariable("RawUnwrap_tmp", ctx.ImportReference(wrapInfo.Type));
          il.Append(Ldloca_S(byRefTempVariable));
        } else {
          il.Append(Ldarg_0());
          il.Append(Ldflda(previousValue));
        }

        il.Append(Call(ctx.ImportReference(wrapInfo.UnwrapMethod)));

        if (wrapInfo.IsRaw) {
          // check if number of bytes checks out
          GenericInstanceMethod validateMethod;
          validateMethod = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.VerifyRawNetworkUnwrap), genericArgsCount: 1));
          validateMethod.GenericArguments.Add(resultType);
          il.Append(Ldc_I4(wrapInfo.MaxRawByteCount));
          il.Append(Call(validateMethod));

          if (ctx.HasOffset) {
            il.AppendMacro(AlignToWordSize());
            il.AppendMacro(ctx.AddOffset());
          } else {
            il.Append(Pop());
          }

        } else {
          il.AppendMacro(ctx.AddOffset(GetByteCount(asm, resultType)));
        }

        prepareStore?.Invoke(il);

        if (previousValue == null) {
          il.Append(Ldloc(byRefTempVariable));
        } else {
          il.Append(Ldarg_0());
          il.Append(Ldfld(previousValue));
        }

        if (!wrapInfo.UnwrapMethod.ReturnType.IsSame(resultType)) {
          il.Append(Cast(resultType));
        }

        storeResult?.Invoke(il);

      } else {

        // if not by ref, we don't handle the previous value field
        Log.Assert(previousValue == null);

        prepareStore?.Invoke(il);

        il.AppendMacro(ctx.LoadRunner());
        il.AppendMacro(ctx.LoadAddress());
        il.Append(Ldind_or_Ldobj(typeToLoad));

        il.Append(Call(ctx.ImportReference(wrapInfo.UnwrapMethod)));

        if (!wrapInfo.UnwrapMethod.ReturnType.IsSame(resultType)) {
          il.Append(Cast(resultType));
        }

        storeResult?.Invoke(il);

        il.AppendMacro(ctx.AddOffset(GetByteCount(asm, resultType)));
      }
    }

    void WeaveSimulation(ILWeaverAssembly asm, TypeDefinition type) {

      if (type.HasGenericParameters) {
        return;
      }

      WeaveRpcs(asm, type, allowInstanceRpcs: false);
    }


    private Instruction[] GetInlineFieldInit(MethodDefinition constructor, FieldDefinition field) {
      var instructions = constructor.Body.Instructions;
      int prevStfld = -1;
      for (int i = 0; i < instructions.Count; ++i) {
        var instruction = instructions[i];
        if (instruction.OpCode == OpCodes.Stfld) {
          // found the store
          if (instruction.Operand == field) {
            int start = prevStfld + 1;
            return instructions.Skip(start).Take(i - start + 1).ToArray();
          } else {
            prevStfld = i;
          }
        } else if (instruction.IsBaseConstructorCall(constructor.DeclaringType)) {
          // base constructor init
          break;
        }
      }
      return Array.Empty<Instruction>();
    }

    private Instruction[] RemoveInlineFieldInit(TypeDefinition type, FieldDefinition field) {
      var constructors = type.GetConstructors().Where(x => !x.IsStatic);
      if (!constructors.Any()) {
        return Array.Empty<Instruction>();
      }

      var firstConstructor = constructors.First();
      var firstInlineInit = GetInlineFieldInit(firstConstructor, field).ToArray();
      if (firstInlineInit.Length != 0) {
        Log.Debug($"Found {field} inline init: {(string.Join("; ", firstInlineInit.Cast<object>()))}");
      }

      foreach (var constructor in constructors.Skip(1)) {
        var otherInlineInit = GetInlineFieldInit(constructor, field);
        if (!firstInlineInit.SequenceEqual(otherInlineInit, new InstructionEqualityComparer())) {
          throw new ILWeaverException($"Expect inline init of {field} to be the same in all constructors," +
            $" but there's a difference between {firstConstructor} and {constructor}");
        }
      }

      foreach (var constructor in constructors) {
        Log.Debug($"Removing inline init of {field} from {constructor}");
        var il = constructor.Body.GetILProcessor();
        var otherInlineInit = GetInlineFieldInit(constructor, field);
        foreach (var instruction in otherInlineInit.Reverse()) {
          Log.Debug($"Removing {instruction}");
          il.Remove(instruction);
        }
      }

      return firstInlineInit;
    }

    private static bool IsMakeInitializerCall(Instruction instruction) {
      if (instruction.OpCode == OpCodes.Call && instruction.Operand is MethodReference method) {
        if (method.DeclaringType.IsSame<NetworkBehaviour>() && method.Name == nameof(NetworkBehaviour.MakeInitializer)) {
          return true;
        }
      }
      return false;
    }

    private static bool IsMakeRefOrMakePtrCall(Instruction instruction) {
      if (instruction.OpCode == OpCodes.Call && instruction.Operand is MethodReference method) {
        if (method.DeclaringType.IsSame<NetworkBehaviour>() && (
          method.Name == nameof(NetworkBehaviour.MakeRef) || method.Name == nameof(NetworkBehaviour.MakePtr)
          )) {
          return true;
        }
      }
      return false;
    }

    private void CheckIfMakeInitializerImplicitCast(Instruction instruction) {
      if (instruction.OpCode == OpCodes.Call && (instruction.Operand as MethodReference)?.Name == "op_Implicit") {
        // all good
      } else {
        throw new ILWeaverException($"Expected an implicit cast, got {instruction}");
      }
    }

    private void ReplaceBackingFieldInInlineInit(ILWeaverAssembly asm, FieldDefinition backingField, FieldDefinition field, ILProcessor il, Instruction[] instructions) {
      bool nextImplicitCast = false;
      foreach (var instruction in instructions) {
        if (nextImplicitCast) {
          CheckIfMakeInitializerImplicitCast(instruction);
          nextImplicitCast = false;
          il.Remove(instruction);
        } else if (instruction.OpCode == OpCodes.Stfld && instruction.Operand == backingField) {
          instruction.Operand = field;
        } else if (IsMakeInitializerCall(instruction)) {
          // dictionaries need one extra step, if using SerializableDictionary :(
          if (ILWeaverSettings.UseSerializableDictionaryForNetworkDictionaryProperties() && backingField.FieldType.IsNetworkDictionary(out var keyType, out var valueType)) {
            var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.MakeSerializableDictionary)));
            m.GenericArguments.Add(keyType);
            m.GenericArguments.Add(valueType);
            Log.Debug($"Inline init for {field}, replacing {instruction.Operand} with {m}");
            instruction.Operand = m;
          } else {
            // remove the op, it will be fine
            Log.Debug($"Inline init for {field}, removing {instruction}");
            il.Remove(instruction);
          }
          nextImplicitCast = true;
        }
      }
    }

    static IEnumerable<TypeDefinition> AllTypeDefs(TypeDefinition definitions) {
      yield return definitions;

      if (definitions.HasNestedTypes) {
        foreach (var nested in definitions.NestedTypes.SelectMany(AllTypeDefs)) {
          yield return nested;
        }
      }
    }

    static IEnumerable<TypeDefinition> AllTypeDefs(Collection<TypeDefinition> definitions) {
      return definitions.SelectMany(AllTypeDefs);
    }

    public bool Weave(ILWeaverAssembly asm) {
      // if we don't have the weaved assembly attribute, we need to do weaving and insert the attribute
      if (asm.CecilAssembly.HasAttribute<NetworkAssemblyWeavedAttribute>() != false) {
        return false;
      }

      using (Log.ScopeAssembly(asm.CecilAssembly)) {
        // grab main module .. this contains all the types we need
        var module = asm.CecilAssembly.MainModule;
        var moduleAllTypes = AllTypeDefs(module.Types).ToArray();

        // go through all types and check for network behaviours
        foreach (var t in moduleAllTypes) {
          if (t.IsValueType && t.Is<INetworkStruct>()) {
            try {
              WeaveStruct(asm, t, null);
            } catch (Exception ex) {
              throw new ILWeaverException($"Failed to weave struct {t}", ex);
            }
          }
        }

        foreach (var t in moduleAllTypes) {
          if (t.IsValueType && t.Is<INetworkInput>()) {
            try {
              WeaveInput(asm, t);
            } catch (Exception ex) {
              throw new ILWeaverException($"Failed to weave input {t}", ex);
            }
          }
        }

        foreach (var t in moduleAllTypes) {
          if (t.IsSubclassOf<NetworkBehaviour>()) {
            try {
              WeaveBehaviour(asm, t);
            } catch (Exception ex) {
              throw new ILWeaverException($"Failed to weave behaviour {t}", ex);
            }
          } else if (t.IsSubclassOf<SimulationBehaviour>()) {
            try {
              WeaveSimulation(asm, t);
            } catch (Exception ex) {
              throw new ILWeaverException($"Failed to weave behaviour {t}", ex);
            }
          }
        }

        // only if it was modified
        if (asm.Modified) {
          // add weaved assembly attribute to this assembly
          asm.CecilAssembly.CustomAttributes.Add(new CustomAttribute(typeof(NetworkAssemblyWeavedAttribute).GetConstructor(asm)));
        }

        return asm.Modified;
      }
    }
  }
}
#endif


#endregion


#region Assets/Photon/FusionCodeGen/ILWeaver.INetworkedStruct.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL
namespace Fusion.CodeGen {
  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using UnityEditor;
  using UnityEditor.Compilation;
  using UnityEngine;
  using System.Runtime.CompilerServices;
  using static Fusion.CodeGen.ILWeaverOpCodes;
  using Mono.Cecil;
  using Mono.Cecil.Cil;
  using Mono.Cecil.Rocks;
  using Mono.Collections.Generic;
  using CompilerAssembly = UnityEditor.Compilation.Assembly;
  using FieldAttributes = Mono.Cecil.FieldAttributes;
  using MethodAttributes = Mono.Cecil.MethodAttributes;
  using ParameterAttributes = Mono.Cecil.ParameterAttributes;

  unsafe partial class ILWeaver {

    const int WordSize = Allocator.REPLICATE_WORD_SIZE;

    private bool IsTypeBlittable(ILWeaverAssembly asm, TypeReference type) {
      if (type.IsPrimitive) {
        return type.IsIntegral();
      } else if (!type.IsValueType) {
        return false;
      } else if (type.IsVector2() || type.IsVector3() || type.IsQuaternion()) {
        return false;
      } else if (type.IsNetworkArray() || type.IsNetworkDictionary() || type.IsNetworkList()) {
        return false;
      } else {
        return true;
      }
    }

    public void WeaveStruct(ILWeaverAssembly asm, TypeDefinition type, TypeReference typeRef) {
      ILWeaverException.DebugThrowIf(!type.Is<INetworkStruct>(), $"Not a {nameof(INetworkStruct)}");

      string typeKey;
      if (type.HasGenericParameters) {
        Log.Assert(typeRef?.IsGenericInstance == true);
        typeKey = typeRef.FullName;
      } else {
        typeKey = type.FullName;
      }

      if (type.TryGetAttribute<NetworkStructWeavedAttribute>(out var attribute)) {

        if (_typeData.ContainsKey(typeKey) == false) {
          var wordCount = attribute.GetAttributeArgument<int>(0);
          if (attribute.TryGetAttributeArgument(1, out bool value, false) && value) {
            Log.Assert(typeRef?.IsGenericInstance == true);
            foreach (var gen in ((GenericInstanceType)typeRef).GenericArguments) {
              if (gen.IsValueType && gen.Is<INetworkStruct>()) {
                wordCount += GetTypeWordCount(asm, gen);
              }
            }
          }

          _typeData.Add(typeKey, new TypeMetaData {
            WordCount = wordCount,
            Definition = type,
            Reference = type
          });
        }

        return;
      }

      using (Log.ScopeStruct(type)) {
        
        int wordCount = WeaveStructInner(asm, type);

        // track type data
        _typeData.Add(typeKey, new TypeMetaData {
          WordCount = wordCount,
          Definition = type,
          Reference = type
        });

        // add new attribute
        type.AddAttribute<NetworkStructWeavedAttribute, int>(asm, wordCount);
      }
    }

    int WeaveStructInner(ILWeaverAssembly asm, TypeDefinition type) {
      // flag asm as modified
      asm.Modified = true;

      // set as explicit layout
      type.IsExplicitLayout = true;

      // clear all backing fields
      foreach (var property in type.Properties) {
        if (!IsWeavableProperty(property, out var propertyInfo)) {
          continue;
        }

        property.ThrowIfStatic();

        if (IsTypeBlittable(asm, property.PropertyType)) {
          Log.Warn($"Networked property {property} should be replaced with a regular field. For structs, " +
            $"[Networked] attribute should to be applied only on collections, booleans, floats and vectors.");
        }

        int fieldIndex = type.Fields.Count;

        if (propertyInfo.BackingField != null) {
          if (!propertyInfo.BackingField.FieldType.IsValueType) {
            Log.Warn($"Networked property {property} has a backing field that is not a value type. To keep unmanaged status," +
              $" the accessor should follow \"{{ get => default; set {{}} }}\" pattern");
          }

          fieldIndex = type.Fields.IndexOf(propertyInfo.BackingField);
          if (fieldIndex >= 0) {
            type.Fields.RemoveAt(fieldIndex);
          }
        }

        try {
          var propertyWordCount = GetPropertyWordCount(asm, property);

          property.GetMethod?.RemoveAttribute<CompilerGeneratedAttribute>(asm);
          property.SetMethod?.RemoveAttribute<CompilerGeneratedAttribute>(asm);

          var getIL = property.GetMethod.Body.GetILProcessor();
          getIL.Clear();
          getIL.Body.Variables.Clear();

          var setIL = property.SetMethod?.Body.GetILProcessor();
          if (setIL != null) {
            setIL.Clear();
            setIL.Body.Variables.Clear();
          }

          var backingFieldName = $"_{property.Name}";
          var fixedBufferInfo = CacheGetFixedBuffer(asm, propertyWordCount);
          var surrogateType = CacheGetUnitySurrogate(asm, property);
          var storageField = new FieldDefinition($"_{property.Name}", FieldAttributes.Private, fixedBufferInfo.Type);

          int capacity;
          if (property.PropertyType.IsNetworkDictionary()) {
            capacity = GetStaticDictionaryCapacity(property);
          } else {
            capacity = GetCapacity(property, 1);
          }
          storageField.AddAttribute<SerializeField>(asm);
          storageField.AddAttribute<FixedBufferPropertyAttribute, TypeReference, TypeReference, int>(asm, property.PropertyType, surrogateType, capacity);

          type.Fields.Insert(fieldIndex, storageField);

          // move field attributes, if any
          if (propertyInfo.BackingField != null) {
            MoveBackingFieldAttributes(asm, propertyInfo.BackingField, storageField);
          }
          MovePropertyAttributesToBackingField(asm, property, storageField);

          InjectValueAccessor(asm, getIL, setIL, property, property.PropertyType, OpCodes.Ldarg_1, (il, offset) => {

            var m = new GenericInstanceMethod(asm.Native.GetMethod(nameof(Native.ReferenceToPointer)));
            m.GenericArguments.Add(storageField.FieldType);

            il.Append(Ldarg_0());
            il.Append(Ldflda(storageField));

            il.Append(Call(m));

          }, false);
        } catch (Exception ex) {
          throw new ILWeaverException($"Failed to weave property {property}", ex);
        }
      }

      // figure out word counts for everything
      var wordCount = 0;

      foreach (var field in type.Fields) {

        // skip statics
        if (field.IsStatic) {
          continue;
        }

        // set offset 
        field.Offset = wordCount * Allocator.REPLICATE_WORD_SIZE;

        try {
          // increase block count
          wordCount += GetTypeWordCount(asm, field.FieldType);
        } catch (Exception ex) {
          throw new ILWeaverException($"Failed to get word count of field {field}", ex);
        }
      }

      return wordCount;
    }
  }
}
#endif


#endregion


#region Assets/Photon/FusionCodeGen/ILWeaver.NetworkBehaviour.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL
namespace Fusion.CodeGen {
  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using UnityEditor;
  using UnityEditor.Compilation;
  using UnityEngine;
  using System.Runtime.CompilerServices;
  using static Fusion.CodeGen.ILWeaverOpCodes;
  using Mono.Cecil;
  using Mono.Cecil.Cil;
  using Mono.Cecil.Rocks;
  using Mono.Collections.Generic;
  using CompilerAssembly = UnityEditor.Compilation.Assembly;
  using FieldAttributes = Mono.Cecil.FieldAttributes;
  using MethodAttributes = Mono.Cecil.MethodAttributes;
  using ParameterAttributes = Mono.Cecil.ParameterAttributes;
  using UnityEngine.Scripting;

  unsafe partial class ILWeaver {

    FieldDefinition AddNetworkBehaviourBackingField(ILWeaverAssembly asm, PropertyDefinition property) {

      TypeReference fieldType = property.PropertyType;
      if (fieldType.IsPointer || fieldType.IsByReference) {
        fieldType = fieldType.GetElementType();
      } else if (fieldType.IsNetworkArray(out var elementType) || fieldType.IsNetworkList(out elementType)) {
        fieldType = TypeReferenceRocks.MakeArrayType(elementType);
      } else if (fieldType.IsNetworkDictionary(out var keyType, out var valueType)) {
        if (ILWeaverSettings.UseSerializableDictionaryForNetworkDictionaryProperties()) {
          fieldType = TypeReferenceRocks.MakeGenericInstanceType(asm.Import(typeof(SerializableDictionary<,>)), keyType, valueType);
        } else {
          fieldType = TypeReferenceRocks.MakeGenericInstanceType(asm.Import(typeof(Dictionary<,>)), keyType, valueType);
        }
      }

      var field = new FieldDefinition(GetInspectorFieldName(property.Name), FieldAttributes.Private, fieldType);
      return field;
    }

    private void MoveBackingFieldAttributes(ILWeaverAssembly asm, FieldDefinition backingField, FieldDefinition storageField) {
      if (backingField.IsNotSerialized) {
        storageField.IsNotSerialized = true;
      }

      foreach (var attrib in backingField.CustomAttributes) {
        if (attrib.AttributeType.Is<CompilerGeneratedAttribute>() ||
            attrib.AttributeType.Is<System.Diagnostics.DebuggerBrowsableAttribute>()) {
          continue;
        }
        storageField.CustomAttributes.Add(attrib);
      }
    }

    private void MovePropertyAttributesToBackingField(ILWeaverAssembly asm, PropertyDefinition property, FieldDefinition field) {
      bool hasNonSerialized = false;

      foreach (var attribute in property.CustomAttributes) {
        if (attribute.AttributeType.IsSame<NetworkedAttribute>() ||
            attribute.AttributeType.IsSame<NetworkedWeavedAttribute>() ||
            attribute.AttributeType.IsSame<AccuracyAttribute>() ||
            attribute.AttributeType.IsSame<CapacityAttribute>()) {
          continue;
        }

        var attribDef = attribute.AttributeType.TryResolve();
        if (attribDef == null) {
          Log.Warn($"Failed to resolve {attribute.AttributeType}, not going to try to apply on {field}");
          continue;
        }


        if (attribDef.TryGetAttribute<UnityPropertyAttributeProxyAttribute>(out var proxy)) {
          Log.Debug($"Found proxy attribute {attribute.AttributeType}, applying to {field}");
          var attribTypeRef = proxy.GetAttributeArgument<TypeReference>(0);
          var attribTypeDef = attribTypeRef.Resolve();

          if (attribTypeDef.TryGetMatchingConstructor(attribute.Constructor.Resolve(), out var constructor)) {
            field.CustomAttributes.Add(new CustomAttribute(property.Module.ImportReference(constructor), attribute.GetBlob()));

            if (attribute.AttributeType.IsSame<UnityNonSerializedAttribute>()) {
              Log.Debug($"{field} marked as NonSerialized, SerializeField will not be applied");
              hasNonSerialized = true;
            }
          } else {
            Log.Warn($"Failed to find matching constructor of {attribTypeDef} for {attribute.Constructor} (field {field})");
          }

          continue;
        }

        if (attribDef.TryGetAttribute<AttributeUsageAttribute>(out var usage)) {
          var targets = usage.GetAttributeArgument<AttributeTargets>(0);
          if ((targets & AttributeTargets.Field) != AttributeTargets.Field) {
            Log.Debug($"Attribute {attribute.AttributeType} can't be applied on a field ({field}), skipping.");
            continue;
          }
        }

        Log.Debug($"Copying {attribute.AttributeType} to {field}");
        field.CustomAttributes.Add(new CustomAttribute(attribute.Constructor, attribute.GetBlob()));
      }

      if (!hasNonSerialized && !property.GetMethod.IsPrivate) {
        if (field.IsNotSerialized) {
          // prohibited
        } else if (field.HasAttribute<SerializeField>()) {
          // already added
        } else { 
          field.AddAttribute<SerializeField>(asm);
        }
      }
    }

    public void WeaveBehaviour(ILWeaverAssembly asm, TypeDefinition type) {
      if (type.HasGenericParameters) {
        return;
      }

      ILWeaverException.DebugThrowIf(!type.IsSubclassOf<NetworkBehaviour>(), $"Not a {nameof(NetworkBehaviour)}");

      if (type.TryGetAttribute<NetworkBehaviourWeavedAttribute>(out var weavedAttribute)) {
        int weavedSize = weavedAttribute.GetAttributeArgument<int>(0);

        if (_networkedBehaviourTypeData.TryGetValue(type.FullName, out var metaData)) {
          Debug.Assert(weavedSize < 0 || weavedSize == metaData.BlockCount);
        } else {
          _networkedBehaviourTypeData.Add(type.FullName, new BehaviourMetaData {
            Definition = type,
            BlockCount = weavedSize >= 0 ? weavedSize : GetNetworkBehaviourWordCount(asm, type)
          });
        }

        return;
      }

      // flag as modified
      asm.Modified = true;

      using (Log.ScopeBehaviour(type)) {

        var changed = asm.Import(typeof(Changed<>)).MakeGenericInstanceType(type);
        var changedDelegate = asm.Import(typeof(ChangedDelegate<>)).MakeGenericInstanceType(type);
        var networkBehaviourCallbacks = asm.Import(typeof(NetworkBehaviourCallbacks<>)).MakeGenericInstanceType(type);
        type.Fields.Add(new FieldDefinition("$IL2CPP_CHANGED", FieldAttributes.Static, changed));
        type.Fields.Add(new FieldDefinition("$IL2CPP_CHANGED_DELEGATE", FieldAttributes.Static, changedDelegate));
        type.Fields.Add(new FieldDefinition("$IL2CPP_NETWORK_BEHAVIOUR_CALLBACKS", FieldAttributes.Static, networkBehaviourCallbacks));

        // get block count of parent as starting point for ourselves
        var wordCount = GetNetworkBehaviourWordCount(asm, type.BaseType.Resolve());

        // this is the data field which holds this behaviours root pointer
        var dataField = GetFieldFromNetworkedBehaviour(asm, type, PTR_FIELD_NAME);

        // find onspawned method
        Func<string, (MethodDefinition, Instruction)> createOverride = (name) => {
          var result = type.Methods.FirstOrDefault(x => x.Name == name);
          if (result != null) {
            // need to find the placeholder method
            var placeholderMethodName = asm.NetworkedBehaviour.GetMethod(nameof(NetworkBehaviour.InvokeWeavedCode)).FullName;
            var placeholders = result.Body.Instructions
              .Where(x => x.OpCode == OpCodes.Call && x.Operand is MethodReference && ((MethodReference)x.Operand).FullName == placeholderMethodName)
              .ToArray();

            if (placeholders.Length != 1) {
              throw new ILWeaverException($"When overriding {name} in a type with [Networked] properties, make sure to call {placeholderMethodName} exactly once somewhere.");
            }

            var placeholder = placeholders[0];
            var il = result.Body.GetILProcessor();

            var jumpTarget = Nop();
            var returnTarget = Nop();

            // this is where to jump after weaved code's done
            il.InsertAfter(placeholder, returnTarget);
            il.InsertAfter(placeholder, Br(jumpTarget));

            il.Append(jumpTarget);
            return (result, Br(returnTarget));
          }

          result = new MethodDefinition(name, MethodAttributes.Public, asm.CecilAssembly.MainModule.ImportReference(typeof(void))) {
            IsVirtual = true,
            IsHideBySig = true,
            IsReuseSlot = true
          };

          var baseMethod = FindMethodInParent(asm, type, name, nameof(SimulationBehaviour));

          // call base method
          if (baseMethod != null) {
            if (baseMethod.DeclaringType.IsSame<NetworkBehaviour>()) {
              // don't call base method
              foreach (var parameter in baseMethod.Parameters) {
                result.Parameters.Add(new ParameterDefinition(parameter.ParameterType));
              }
            } else {
              var bodyIL = result.Body.GetILProcessor();

              bodyIL.Append(Instruction.Create(OpCodes.Ldarg_0));

              foreach (var parameter in baseMethod.Parameters) {
                var p = new ParameterDefinition(parameter.ParameterType);
                result.Parameters.Add(p);
                bodyIL.Append(Ldarg(p));
              }

              bodyIL.Append(Instruction.Create(OpCodes.Call, baseMethod));
            }
          }

          type.Methods.Add(result);
          return (result, Ret());
        };

        var setDefaults = new Lazy<(MethodDefinition, Instruction)>(() => createOverride(nameof(NetworkBehaviour.CopyBackingFieldsToState)));
        var getDefaults = new Lazy<(MethodDefinition, Instruction)>(() => createOverride(nameof(NetworkBehaviour.CopyStateToBackingFields)));

        FieldDefinition lastAddedFieldWithKnownPosition = null;
        List<FieldDefinition> fieldsWithUncertainPosition = new List<FieldDefinition>();

        foreach (var property in type.Properties) {
          if (IsWeavableProperty(property, out var propertyInfo) == false) {
            continue;
          }

          property.ThrowIfStatic();

          if (!string.IsNullOrEmpty(propertyInfo.OnChanged)) {
            WeaveChangedHandler(asm, property, propertyInfo.OnChanged);
          }


          if (property.PropertyType.IsPointer || property.PropertyType.IsByReference) {
            var elementType = property.PropertyType.GetElementType();
            if (!IsTypeBlittable(asm, elementType)) {
              Log.Warn($"Property {property} type ({elementType}) is not safe to in pointer/reference properties. " +
                $"Consider wrapping it with a struct implementing INetworkStruct and a [Networked] property.");
            }
          }


          try {
            // try to maintain fields order
            int backingFieldIndex = type.Fields.Count;
            if (propertyInfo.BackingField != null) {
              backingFieldIndex = type.Fields.IndexOf(propertyInfo.BackingField);
              if (backingFieldIndex >= 0) {
                type.Fields.RemoveAt(backingFieldIndex);
              } else {
                Log.Warn($"Unable to find backing field for {property}");
                backingFieldIndex = type.Fields.Count;
              }
            }

            var readOnlyInit = GetReadOnlyPropertyInitializer(property);

            // prepare getter/setter methods


            var (getter, setter) = PreparePropertyForWeaving(property);

            // capture word count in case we re-use the lambda that is created later on ...
            var wordOffset = wordCount;

            // perform injection
            InjectValueAccessor(asm, getter.Body.GetILProcessor(), setter?.Body?.GetILProcessor(), property, property.PropertyType, OpCodes.Ldarg_1,
              (il, offset) => LoadDataAddress(il, dataField, wordOffset + offset), true);

            var propertyWordCount = GetPropertyWordCount(asm, property);

            // step up wordcount
            wordCount += propertyWordCount;

            // inject attribute to poll weaver data during runtime
            property.AddAttribute<NetworkedWeavedAttribute, int, int>(asm, wordOffset, propertyWordCount);



            if (property.HasAttribute<UnityNonSerializedAttribute>() || propertyInfo.BackingField?.IsNotSerialized == true) {
              // so the property is not serialized, so there will be no backing field.

              IEnumerable<Instruction> fieldInit = null;
              VariableDefinition[] fieldInitLocalVariables = null;

              if (readOnlyInit != null) {
                fieldInit = readOnlyInit.Value.Instructions;
                fieldInitLocalVariables = readOnlyInit.Value.Variables;
              } else {
                fieldInit = RemoveInlineFieldInit(type, propertyInfo.BackingField);
                fieldInitLocalVariables = Array.Empty<VariableDefinition>();
              }

              if (fieldInit?.Any() == true) {
                // need to patch defaults with this, but only during the initial set
                var il = setDefaults.Value.Item1.Body.GetILProcessor();
                var postInit = Nop();
                il.Append(Ldarg_1());
                il.Append(Brfalse(postInit));

                foreach (var loc in fieldInitLocalVariables) {
                  il.Body.Variables.Add(loc);
                }

                if (property.PropertyType.IsPointer ||
                    property.PropertyType.IsByReference) {
                  // load up address
                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                } else if (property.PropertyType.IsNetworkArray() ||
                  property.PropertyType.IsNetworkList() ||
                  property.PropertyType.IsNetworkDictionary()) {

                  var first = fieldInit.First();
                  // needs some special init
                  Log.AssertMessage(first.OpCode == OpCodes.Ldarg_0, $"Expected Ldarg_0, got: {first}");
                  il.Append(first);
                  il.Append(Call(getter));
                  fieldInit = fieldInit.Skip(1);
                }

                bool skipImplicitInitializerCast = false;
                foreach (var instruction in fieldInit) {
                  if (instruction.IsLdlocWithIndex(out var index)) {
                    var repl = Ldloc(fieldInitLocalVariables[index], il.Body.Method);
                    il.Append(repl);
                  } else if (skipImplicitInitializerCast) {
                    skipImplicitInitializerCast = false;
                    CheckIfMakeInitializerImplicitCast(instruction);
                  } else if (instruction.OpCode == OpCodes.Stfld && instruction.Operand == propertyInfo.BackingField) {
                    // arrays and dictionaries don't have setters
                    if (property.PropertyType.IsPointer || property.PropertyType.IsByReference) {
                      il.Append(Stind_or_Stobj(property.PropertyType.GetElementType()));
                    } else if (property.PropertyType.IsNetworkArray(out var elementType)) {
                      var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.InitializeNetworkArray)));
                      m.GenericArguments.Add(elementType);
                      il.Append(Ldstr(property.Name));
                      il.Append(Call(m));
                    } else if (property.PropertyType.IsNetworkList(out elementType)) {
                      var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.InitializeNetworkList)));
                      m.GenericArguments.Add(elementType);
                      il.Append(Ldstr(property.Name));
                      il.Append(Call(m));
                    } else if (property.PropertyType.IsNetworkDictionary(out var keyType, out var valueType)) {
                      var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.InitializeNetworkDictionary)));
                      m.GenericArguments.Add(TypeReferenceRocks.MakeGenericInstanceType(asm.Import(typeof(Dictionary<,>)), keyType, valueType));
                      m.GenericArguments.Add(keyType);
                      m.GenericArguments.Add(valueType);
                      il.Append(Ldstr(property.Name));
                      il.Append(Call(m));
                    } else {
                      il.Append(Call(setter));
                    }
                  } else if (IsMakeInitializerCall(instruction)) {
                    skipImplicitInitializerCast = true;
                  } else {
                    il.Append(instruction);
                  }
                }

                if (property.PropertyType.IsPointer || property.PropertyType.IsByReference) {
                  il.Append(Stind_or_Stobj(property.PropertyType.GetElementType()));
                }

                il.Append(postInit);
              }

            } else {

              FieldDefinition defaultField;

              if (string.IsNullOrEmpty(propertyInfo.DefaultFieldName)) {
                defaultField = AddNetworkBehaviourBackingField(asm, property);
                if (propertyInfo.BackingField != null) {
                  type.Fields.Insert(backingFieldIndex, defaultField);
                  MoveBackingFieldAttributes(asm, propertyInfo.BackingField, defaultField);

                  if (lastAddedFieldWithKnownPosition == null) {
                    // fixup fields that have been added without knowing their index
                    foreach (var f in fieldsWithUncertainPosition) {
                      type.Fields.Remove(f);
                    }

                    var index = type.Fields.IndexOf(defaultField);
                    fieldsWithUncertainPosition.Reverse();
                    foreach (var f in fieldsWithUncertainPosition) {
                      type.Fields.Insert(index, f);
                    }
                  }

                  lastAddedFieldWithKnownPosition = defaultField;

                } else { 
                  if (lastAddedFieldWithKnownPosition == null) {
                    // not sure where to put this... append
                    type.Fields.Add(defaultField);
                    fieldsWithUncertainPosition.Add(defaultField);
                  } else {
                    // add after the previous field
                    var index = type.Fields.IndexOf(lastAddedFieldWithKnownPosition);
                    Log.Assert(index >= 0);

                    type.Fields.Insert(index+1, defaultField);
                    lastAddedFieldWithKnownPosition = defaultField;
                  }
                }
                MovePropertyAttributesToBackingField(asm, property, defaultField);
              } else {
                defaultField = property.DeclaringType.GetFieldOrThrow(propertyInfo.DefaultFieldName);
              }

              // in each constructor, replace inline init, if present
              foreach (var constructor in type.GetConstructors()) {

                if (readOnlyInit != null) {
                  var il = constructor.Body.GetILProcessor();

                  Instruction before = il.Body.Instructions[0];
                  {
                    // find where to plug in; after last stfld, but before base constructor call
                    for (int i = 0; i < il.Body.Instructions.Count; ++i) {
                      var instruction = il.Body.Instructions[i];
                      if (instruction.IsBaseConstructorCall(type)) {
                        break;
                      } else if (instruction.OpCode == OpCodes.Stfld) {
                        before = il.Body.Instructions[i + 1];
                      }
                    }
                  }

                  // clone variables
                  var (instructions, variables) = CloneInstructions(readOnlyInit.Value.Instructions, readOnlyInit.Value.Variables);

                  foreach (var variable in variables) {
                    il.Body.Variables.Add(variable);
                  }

                  il.InsertBefore(before, Ldarg_0());
                  foreach (var instruction in instructions) {
                    il.InsertBefore(before, instruction);
                  }
                  il.InsertBefore(before, Stfld(defaultField));
                } else {
                  // remove the inline init, if present
                  var init = GetInlineFieldInit(constructor, propertyInfo.BackingField);
                  if (init.Length > 0) {
                    ReplaceBackingFieldInInlineInit(asm, propertyInfo.BackingField, defaultField, constructor.Body.GetILProcessor(), init);
                  }
                }
              }

              defaultField.AddAttribute<DefaultForPropertyAttribute, string, int, int>(asm, property.Name, wordOffset, propertyWordCount);

              {
                var il = setDefaults.Value.Item1.Body.GetILProcessor();

                if (property.PropertyType.IsByReference || property.PropertyType.IsPointer) {
                  il.Append(Ldarg_0());
                  il.Append(Call(getter));

                  il.Append(Ldarg_0());
                  il.Append(Ldfld(defaultField));

                  il.Append(Stind_or_Stobj(property.PropertyType.GetElementType()));

                } else if (property.PropertyType.IsNetworkDictionary(out var keyType, out var valueType)) {

                  var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.InitializeNetworkDictionary)));
                  m.GenericArguments.Add(defaultField.FieldType);
                  m.GenericArguments.Add(keyType);
                  m.GenericArguments.Add(valueType);

                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                  il.Append(Ldarg_0());
                  il.Append(Ldfld(defaultField));
                  il.Append(Ldstr(property.Name));
                  il.Append(Call(m));

                } else if (property.PropertyType.IsNetworkArray(out var elementType)) {

                  var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.InitializeNetworkArray)));
                  m.GenericArguments.Add(elementType);
                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                  il.Append(Ldarg_0());
                  il.Append(Ldfld(defaultField));
                  il.Append(Ldstr(property.Name));
                  il.Append(Call(m));

                } else if (property.PropertyType.IsNetworkList(out elementType)) {

                  var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.InitializeNetworkList)));
                  m.GenericArguments.Add(elementType);
                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                  il.Append(Ldarg_0());
                  il.Append(Ldfld(defaultField));
                  il.Append(Ldstr(property.Name));
                  il.Append(Call(m));


                } else {
                  Log.AssertMessage(setter != null, $"{property} expected to have a setter");
                  il.Append(Ldarg_0());
                  il.Append(Ldarg_0());
                  il.Append(Ldfld(defaultField));
                  il.Append(Call(setter));
                }
              }

              {
                var il = getDefaults.Value.Item1.Body.GetILProcessor();

                if (property.PropertyType.IsByReference || property.PropertyType.IsPointer) {
                  il.Append(Ldarg_0());
                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                  il.Append(Ldind_or_Ldobj(property.PropertyType.GetElementType()));
                  il.Append(Stfld(defaultField));

                } else if (property.PropertyType.IsNetworkDictionary(out var keyType, out var valueType)) {

                  var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.CopyFromNetworkDictionary)));
                  m.GenericArguments.Add(defaultField.FieldType);
                  m.GenericArguments.Add(keyType);
                  m.GenericArguments.Add(valueType);

                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                  il.Append(Ldarg_0());
                  il.Append(Ldflda(defaultField));
                  il.Append(Call(m));

                } else if (property.PropertyType.IsNetworkArray(out var elementType)) {

                  var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.CopyFromNetworkArray)));
                  m.GenericArguments.Add(elementType);

                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                  il.Append(Ldarg_0());
                  il.Append(Ldflda(defaultField));
                  il.Append(Call(m));

                } else if (property.PropertyType.IsNetworkList(out elementType)) {

                  var m = new GenericInstanceMethod(asm.NetworkBehaviourUtils.GetMethod(nameof(NetworkBehaviourUtils.CopyFromNetworkList)));
                  m.GenericArguments.Add(elementType);

                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                  il.Append(Ldarg_0());
                  il.Append(Ldflda(defaultField));
                  il.Append(Call(m));

                } else {
                  Log.AssertMessage(getter != null, $"{property} expected to have a getter");
                  il.Append(Ldarg_0());
                  il.Append(Ldarg_0());
                  il.Append(Call(getter));
                  il.Append(Stfld(defaultField));
                }
              }
            }
          } catch (Exception ex) {
            throw new ILWeaverException($"Failed to weave property {property}", ex);
          }
        }

        if (setDefaults.IsValueCreated) {
          var (method, instruction) = setDefaults.Value;
          method.Body.GetILProcessor().Append(instruction);
        }
        if (getDefaults.IsValueCreated) {
          var (method, instruction) = getDefaults.Value;
          method.Body.GetILProcessor().Append(instruction);
        }

        // add meta attribute
        var metaAttribute = GetMetaAttributeConstructor(asm);
        var metaAttributeCtor = new CustomAttribute(metaAttribute);
        metaAttributeCtor.ConstructorArguments.Add(new CustomAttributeArgument(ImportType<int>(asm), wordCount));
        type.CustomAttributes.Add(metaAttributeCtor);

        // add to type data lookup
        _networkedBehaviourTypeData.Add(type.FullName, new BehaviourMetaData {
          Definition = type,
          BlockCount = wordCount
        });

        WeaveRpcs(asm, type);
      }
    }

    private void WeaveChangedHandler(ILWeaverAssembly asm, PropertyDefinition property, string handlerName) {

      // find the handler
      {
        foreach (var declaringType in property.DeclaringType.GetHierarchy()) {
          var candidates = declaringType.GetMethods()
            .Where(x => x.IsStatic)
            .Where(x => x.Name == handlerName)
            .Where(x => x.HasParameters && x.Parameters.Count == 1)
            .Where(x => {
              var parameterType = x.Parameters[0].ParameterType;
              if (!parameterType.IsGenericInstance) {
                return false;
              }
              var openGenericType = parameterType.GetElementType();
              if (!openGenericType.IsSame(typeof(Changed<>))) {
                return false;
              }
              var behaviourType = ((GenericInstanceType)parameterType).GenericArguments[0];
              if (!property.DeclaringType.Is(behaviourType)) {
                return false;
              }
              return true;
            })
            .ToList();

          if (candidates.Count > 1) {
            throw new ILWeaverException($"Ambiguous match for OnChanged handler for {property}: {string.Join("; ", candidates)}");
          } else if (candidates.Count == 1) {

            var handler = candidates[0];

            Log.Debug($"OnChanged handler for {property}: {handler}");
            // add preserve attribute, if not added already
            if (!handler.TryGetAttribute<PreserveAttribute>(out _)) {
              handler.AddAttribute<PreserveAttribute>(asm);
              Log.Debug($"Added {nameof(PreserveAttribute)} to {handler}");
            }
            return;
          }
        }
      }

      throw new ILWeaverException($"No match found for OnChanged handler for {property}");
    }

    struct ReadOnlyInitializer {
      public Instruction[] Instructions;
      public VariableDefinition[] Variables;
    }

    private ReadOnlyInitializer? GetReadOnlyPropertyInitializer(PropertyDefinition property) {
      if (property.PropertyType.IsPointer || property.PropertyType.IsByReference) {
        // need to check if there's MakeRef/Ptr before getter gets obliterated 
        var instructions = property.GetMethod.Body.Instructions;

        for (int i = 0; i < instructions.Count; ++i) {
          var instr = instructions[i];
          if (IsMakeRefOrMakePtrCall(instr)) {
            Log.Debug($"Property {property} has MakePtr/MakeRef init");
            // found it!
            if (i == 0) {
              // seems we're dealing with an empty MakeRef/MakePtr
              return null;
            } else {
              return new ReadOnlyInitializer() {
                Instructions = instructions.Take(i).ToArray(),
                Variables = property.GetMethod.Body.Variables.ToArray()
              };
            }
          }
        }
      }
      return null;
    }

    private (Instruction[], VariableDefinition[]) CloneInstructions(Instruction[] source, VariableDefinition[] sourceVariables) {

      var constructor = typeof(Instruction).GetConstructor(
        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null,
        new[] { typeof(OpCode), typeof(object) }, null);

      // shallow copy
      var result = source.Select(x => (Instruction)constructor.Invoke(new[] { x.OpCode, x.Operand }))
        .ToArray();

      var variableMapping = new Dictionary<VariableDefinition, VariableDefinition>();

      // now need to resolve local variables and jump targets
      foreach (var instruction in result) {

        if (instruction.IsLdlocWithIndex(out var locIndex) || instruction.IsStlocWithIndex(out locIndex)) {
          var variable = sourceVariables[locIndex];
          if (!variableMapping.TryGetValue(variable, out var replacement)) {
            replacement = new VariableDefinition(variable.VariableType);
            variableMapping.Add(variable, replacement);
          }
          if (instruction.IsLdlocWithIndex(out _)) {
            instruction.OpCode = OpCodes.Ldloc;
          } else {
            instruction.OpCode = OpCodes.Stloc;
          }
          instruction.Operand = replacement;
        } else if (instruction.Operand is VariableDefinition variable) {
          if (!variableMapping.TryGetValue(variable, out var replacement)) {
            replacement = new VariableDefinition(variable.VariableType);
            variableMapping.Add(variable, replacement);
          }
          instruction.Operand = replacement;
        } else if (instruction.Operand is Instruction target) {
          var targetIndex = Array.IndexOf(source, target);
          Log.Assert(targetIndex >= 0);
          instruction.Operand = result[targetIndex];
        } else if (instruction.Operand is Instruction[] targets) {
          instruction.Operand = targets.Select(x => {
            var targetIndex = Array.IndexOf(source, x);
            Log.Assert(targetIndex >= 0);
            return result[targetIndex];
          });
        } else if (instruction.Operand is ParameterDefinition) {
          throw new NotSupportedException();
        }
      }

      return (result, variableMapping.Values.ToArray());
    }
  }
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverAssembly.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL
namespace Fusion.CodeGen {
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Reflection;
  using Assembly = UnityEditor.Compilation.Assembly;

  using Mono.Cecil;

  public class ILWeaverImportedType {
    public Type                 ClrType;
    public ILWeaverAssembly     Assembly;
    public List<TypeDefinition> BaseDefinitions;
    public TypeReference        Reference;

    Dictionary<string, FieldReference>  _fields        = new Dictionary<string, FieldReference>();
    Dictionary<(string, int?), MethodReference> _methods = new Dictionary<(string, int?), MethodReference>();
    Dictionary<string, MethodReference> _propertiesGet = new Dictionary<string, MethodReference>();
    Dictionary<string, MethodReference> _propertiesSet = new Dictionary<string, MethodReference>();

    public static implicit operator TypeReference(ILWeaverImportedType type) => type.Reference;

    public ILWeaverImportedType(ILWeaverAssembly asm, Type type) {
      ClrType    = type;
      Assembly   = asm;

      Type baseType = type;
      BaseDefinitions = new List<TypeDefinition>();
      // Store the type, and each of its base types - so we can later find fields/properties/methods in the base class.
      while (baseType != null) {
        BaseDefinitions.Add(asm.CecilAssembly.MainModule.ImportReference(baseType).Resolve());
        baseType = baseType.BaseType;
      }

      Reference = asm.CecilAssembly.MainModule.ImportReference(BaseDefinitions[0]);
    }

    public FieldReference GetField(string name) {
      bool found = _fields.TryGetValue(name, out var fieldRef);
      if (found == false) {
        for (int i = 0; i < BaseDefinitions.Count; ++i) {
          FieldDefinition typeDef = BaseDefinitions[i].Fields.FirstOrDefault(x => x.Name == name);
          if (typeDef != null) {
            fieldRef = Assembly.CecilAssembly.MainModule.ImportReference(typeDef);
            _fields.Add(name, fieldRef);
            return fieldRef;
          }
        }
      }
      return fieldRef;
    }

    public MethodReference GetProperty(string name) {
      bool found = _propertiesGet.TryGetValue(name, out var methRef);
      if (found == false) {
        for (int i = 0; i < BaseDefinitions.Count; ++i) {
          PropertyDefinition typeDef = BaseDefinitions[i].Properties.FirstOrDefault(x => x.Name == name);
          if (typeDef != null) {
            methRef = Assembly.CecilAssembly.MainModule.ImportReference(typeDef.GetMethod);
            _propertiesGet.Add(name, methRef);
            return methRef;
          }
        }
      }
      return methRef;
    }

    public MethodReference SetProperty(string name) {
      bool found = _propertiesSet.TryGetValue(name, out var methRef);
      if (found == false) {
        for (int i = 0; i < BaseDefinitions.Count; ++i) {
          PropertyDefinition def = BaseDefinitions[i].Properties.FirstOrDefault(x => x.Name == name);
          if (def != null) {
            methRef = Assembly.CecilAssembly.MainModule.ImportReference(def.SetMethod);
            _propertiesSet.Add(name, methRef);
            return methRef;
          }
        }
      }
      return methRef;
    }

    public MethodReference GetMethod(string name, int? argsCount = null, int? genericArgsCount = null) {
      bool found = _methods.TryGetValue((name, argsCount), out var methRef);
      if (found == false) {
        for (int i = 0; i < BaseDefinitions.Count; ++i) {
          
          var typeDef = BaseDefinitions[i].Methods.FirstOrDefault(
            x => x.Name == name &&
            (argsCount.HasValue == false || x.Parameters.Count == argsCount.Value) &&
            (genericArgsCount == null || x.GenericParameters.Count == genericArgsCount.Value));

          if (typeDef != null) {
            methRef = Assembly.CecilAssembly.MainModule.ImportReference(typeDef);
            _methods.Add((name, argsCount), methRef);
            return methRef;
          }
        }
      }
      if (methRef == null) {
        throw new InvalidOperationException($"Not found: {name}");
      }
      return methRef;
    }


    public GenericInstanceMethod GetGenericMethod(string name, int? argsCount = null, params TypeReference[] types) {
      var method  = GetMethod(name, argsCount);
      var generic = new GenericInstanceMethod(method);

      foreach (var t in types) {
        generic.GenericArguments.Add(t);
      }

      return generic;
    }
  }

  public class ILWeaverAssembly {
    public bool         Modified;
    public List<String> Errors = new List<string>();

    public AssemblyDefinition CecilAssembly;

    ILWeaverImportedType _networkRunner;
    ILWeaverImportedType _readWriteUtils;
    ILWeaverImportedType _nativeUtils;
    ILWeaverImportedType _rpcInfo;
    ILWeaverImportedType _rpcInvokeInfo;
    ILWeaverImportedType _rpcHeader;
    ILWeaverImportedType _networkBehaviourUtils;

    ILWeaverImportedType _simulation;
    ILWeaverImportedType _networkedObject;
    ILWeaverImportedType _networkedObjectId;
    ILWeaverImportedType _networkedBehaviour;
    ILWeaverImportedType _networkedBehaviourId;
    ILWeaverImportedType _simulationBehaviour;
    ILWeaverImportedType _simulationMessage;

    ILWeaverImportedType _object;
    ILWeaverImportedType _valueType;
    ILWeaverImportedType _void;
    ILWeaverImportedType _int;
    ILWeaverImportedType _float;

    Dictionary<Type, TypeReference> _types = new Dictionary<Type, TypeReference>();

    private ILWeaverImportedType MakeImportedType<T>(ref ILWeaverImportedType field) {
      return MakeImportedType(ref field, typeof(T));
    }

    private ILWeaverImportedType MakeImportedType(ref ILWeaverImportedType field, Type type) {
      if (field == null) {
        field = new ILWeaverImportedType(this, type);
      }
      return field;
    }

    public ILWeaverImportedType WordSizedPrimitive => MakeImportedType<int>(ref _int);

    public ILWeaverImportedType Void => MakeImportedType(ref _void, typeof(void));

    public ILWeaverImportedType Object => MakeImportedType<object>(ref _object);

    public ILWeaverImportedType ValueType => MakeImportedType<ValueType>(ref _valueType);

    public ILWeaverImportedType Float => MakeImportedType<float>(ref _float);

    public ILWeaverImportedType NetworkedObject => MakeImportedType<NetworkObject>(ref _networkedObject);

    public ILWeaverImportedType Simulation => MakeImportedType<Simulation>(ref _simulation);

    public ILWeaverImportedType SimulationMessage => MakeImportedType<SimulationMessage>(ref _simulationMessage);

    public ILWeaverImportedType NetworkedBehaviour => MakeImportedType<NetworkBehaviour>(ref _networkedBehaviour);

    public ILWeaverImportedType SimulationBehaviour => MakeImportedType<SimulationBehaviour>(ref _simulationBehaviour);

    public ILWeaverImportedType NetworkId => MakeImportedType<NetworkId>(ref _networkedObjectId);

    public ILWeaverImportedType NetworkedBehaviourId => MakeImportedType<NetworkBehaviourId>(ref _networkedBehaviourId);

    public ILWeaverImportedType NetworkRunner => MakeImportedType<NetworkRunner>(ref _networkRunner);

    public ILWeaverImportedType ReadWriteUtils => MakeImportedType(ref _readWriteUtils, typeof(ReadWriteUtilsForWeaver));
    
    public ILWeaverImportedType Native => MakeImportedType(ref _nativeUtils, typeof(Native));

    public ILWeaverImportedType NetworkBehaviourUtils => MakeImportedType(ref _networkBehaviourUtils, typeof(NetworkBehaviourUtils));

    public ILWeaverImportedType RpcHeader => MakeImportedType<RpcHeader>(ref _rpcHeader);

    public ILWeaverImportedType RpcInfo => MakeImportedType<RpcInfo>(ref _rpcInfo);

    public ILWeaverImportedType RpcInvokeInfo => MakeImportedType<RpcInvokeInfo>(ref _rpcInvokeInfo);

    public TypeReference Import(TypeReference type) {
      return CecilAssembly.MainModule.ImportReference(type);
    }

    public MethodReference Import(MethodInfo method) {
      return CecilAssembly.MainModule.ImportReference(method);
    }

    public MethodReference Import(MethodReference method) {
      return CecilAssembly.MainModule.ImportReference(method);
    }

    public MethodReference Import(ConstructorInfo method) {
      return CecilAssembly.MainModule.ImportReference(method);
    }

    public TypeReference Import(Type type) {
      if (_types.TryGetValue(type, out var reference) == false) {
        _types.Add(type, reference = CecilAssembly.MainModule.ImportReference(type));
      }

      return reference;
    }

    public void Dispose() {
      CecilAssembly?.Dispose();

      Modified = false;
      Errors.Clear();
      CecilAssembly    = null;
    }

    public TypeReference Import<T>() {
      return Import(typeof(T));
    }
  }
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverAssemblyResolver.ILPostProcessor.cs

#if FUSION_WEAVER && FUSION_WEAVER_ILPOSTPROCESSOR && FUSION_HAS_MONO_CECIL

namespace Fusion.CodeGen {

  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using Mono.Cecil;

  internal class ILWeaverAssemblyResolver : IAssemblyResolver {
    private List<string> _lookInDirectories;
    private Dictionary<string, string> _assemblyNameToPath;
    private Dictionary<string, AssemblyDefinition> _resolvedAssemblies = new Dictionary<string, AssemblyDefinition>();
    private string _compiledAssemblyName;
    private ILWeaverLog _log;

    public AssemblyDefinition WeavedAssembly;

    public ILWeaverAssemblyResolver(ILWeaverLog log, string compiledAssemblyName, string[] references) {
      _log                  = log;
      _compiledAssemblyName = compiledAssemblyName;
      _assemblyNameToPath   = new Dictionary<string, string>();

      foreach (var referencePath in references) {
        var assemblyName = Path.GetFileNameWithoutExtension(referencePath);
        if (_assemblyNameToPath.TryGetValue(assemblyName, out var existingPath)) {
          _log.Warn($"Assembly {assemblyName} (full path: {referencePath}) already referenced by {compiledAssemblyName} at {existingPath}");
        } else {
          _assemblyNameToPath.Add(assemblyName, referencePath);
        }
      }

      _lookInDirectories = references.Select(x => Path.GetDirectoryName(x)).Distinct().ToList();
    }

    public void Dispose() {
    }

    public AssemblyDefinition Resolve(AssemblyNameReference name) {
      return Resolve(name, new ReaderParameters(ReadingMode.Deferred));
    }

    public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters) {
      {
        if (name.Name == _compiledAssemblyName)
          return WeavedAssembly;

        var path = GetAssemblyPath(name);
        if (string.IsNullOrEmpty(path))
          return null;

        if (_resolvedAssemblies.TryGetValue(path, out var result))
          return result;

        parameters.AssemblyResolver = this;

        var pdb = path + ".pdb";
        if (File.Exists(pdb)) {
          parameters.SymbolStream = CreateAssemblyStream(pdb);
        }

        var assemblyDefinition = AssemblyDefinition.ReadAssembly(CreateAssemblyStream(path), parameters);
        _resolvedAssemblies.Add(path, assemblyDefinition);
        return assemblyDefinition;
      }
    }

    private string GetAssemblyPath(AssemblyNameReference name) {
      if (_assemblyNameToPath.TryGetValue(name.Name, out var path)) {
        return path;
      }

      // fallback for second-order references
      foreach (var parentDir in _lookInDirectories) {
        var fullPath = Path.Combine(parentDir, name.Name + ".dll");
        if (File.Exists(fullPath)) {
          _assemblyNameToPath.Add(name.Name, fullPath);
          return fullPath;
        }
      }

      return null;
    }

    private static MemoryStream CreateAssemblyStream(string fileName) {
      var bytes = File.ReadAllBytes(fileName);
      return new MemoryStream(bytes);
    }
  }
}

#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverAssemblyResolver.UnityEditor.cs

#if FUSION_WEAVER && !FUSION_WEAVER_ILPOSTPROCESSOR && FUSION_HAS_MONO_CECIL

namespace Fusion.CodeGen {
  using System;
  using System.Collections.Generic;
  using Mono.Cecil;
  using CompilerAssembly = UnityEditor.Compilation.Assembly;

  class ILWeaverAssemblyResolver : BaseAssemblyResolver {
    Dictionary<string, ILWeaverAssembly> _assemblies;
    Dictionary<string, ILWeaverAssembly> _assembliesByPath;

    public IEnumerable<ILWeaverAssembly> Assemblies => _assemblies.Values;

    public ILWeaverAssemblyResolver() {
      _assemblies = new Dictionary<string, ILWeaverAssembly>(StringComparer.Ordinal);
      _assembliesByPath = new Dictionary<string, ILWeaverAssembly>();
    }

    public sealed override AssemblyDefinition Resolve(AssemblyNameReference name) {
      if (_assemblies.TryGetValue(name.FullName, out var asm) == false) {
        asm = new ILWeaverAssembly();
        asm.CecilAssembly = base.Resolve(name, ReaderParameters(false, false));

        _assemblies.Add(name.FullName, asm);
      }

      return asm.CecilAssembly;
    }

    public void Clear() {
      _assemblies.Clear();
    }

    public bool Contains(CompilerAssembly compilerAssembly) {
      return _assembliesByPath.ContainsKey(compilerAssembly.outputPath);
    }

    public ILWeaverAssembly AddAssembly(string path, bool readWrite = true, bool readSymbols = true) {
      return AddAssembly(AssemblyDefinition.ReadAssembly(path, ReaderParameters(readWrite, readSymbols)), null);
    }

    public ILWeaverAssembly AddAssembly(CompilerAssembly compilerAssembly, bool readWrite = true, bool readSymbols = true) {
      return AddAssembly(AssemblyDefinition.ReadAssembly(compilerAssembly.outputPath, ReaderParameters(readWrite, readSymbols)), compilerAssembly);
    }

    public ILWeaverAssembly AddAssembly(AssemblyDefinition assembly, CompilerAssembly compilerAssembly) {
      if (assembly == null) {
        throw new ArgumentNullException(nameof(assembly));
      }

      if (_assemblies.TryGetValue(assembly.Name.FullName, out var asm) == false) {
        asm = new ILWeaverAssembly();
        asm.CecilAssembly = assembly;

        _assemblies.Add(assembly.Name.FullName, asm);

        if (compilerAssembly != null) {
          Assert.Always(_assembliesByPath.ContainsKey(compilerAssembly.outputPath) == false);
          _assembliesByPath.Add(compilerAssembly.outputPath, asm);
        }
      }

      return asm;
    }

    protected override void Dispose(bool disposing) {
      foreach (var asm in _assemblies.Values) {
        asm.CecilAssembly?.Dispose();
      }

      _assemblies.Clear();

      base.Dispose(disposing);
    }

    ReaderParameters ReaderParameters(bool readWrite, bool readSymbols) {
      ReaderParameters p;
      p = new ReaderParameters(ReadingMode.Immediate);
      p.ReadWrite = readWrite;
      p.ReadSymbols = readSymbols;
      p.AssemblyResolver = this;
      return p;
    }
  }
}

#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverBindings.ILPostProcessor.cs

#if FUSION_WEAVER_ILPOSTPROCESSOR
namespace Fusion.CodeGen {
  using System;
  using Unity.CompilationPipeline.Common.ILPostProcessing;

#if FUSION_WEAVER
  using System.Collections.Generic;
  using Unity.CompilationPipeline.Common.Diagnostics;
#if FUSION_HAS_MONO_CECIL
  using System.IO;
  using System.Linq;
  using Mono.Cecil;
  using Mono.Cecil.Cil;
  using System.Reflection;

  class ILWeaverBindings : ILPostProcessor {

    public override ILPostProcessor GetInstance() {
      return this;
    }

    static ILWeaverAssembly CreateWeaverAssembly(ILWeaverLog log, ICompiledAssembly compiledAssembly) {
      var resolver = new ILWeaverAssemblyResolver(log, compiledAssembly.Name, compiledAssembly.References);

      var readerParameters = new ReaderParameters {
        SymbolStream = new MemoryStream(compiledAssembly.InMemoryAssembly.PdbData.ToArray()),
        SymbolReaderProvider = new PortablePdbReaderProvider(),
        AssemblyResolver = resolver,
        ReadingMode = ReadingMode.Immediate,
        ReadWrite = true,
        ReadSymbols = true,
        ReflectionImporterProvider = new ReflectionImporterProvider(log)
      };

      var peStream = new MemoryStream(compiledAssembly.InMemoryAssembly.PeData.ToArray());
      var assemblyDefinition = AssemblyDefinition.ReadAssembly(peStream, readerParameters);

      resolver.WeavedAssembly = assemblyDefinition;

      return new ILWeaverAssembly() {
        CecilAssembly = assemblyDefinition,
      };
    }

    public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly) {

      ILPostProcessResult result;
      var log = new ILWeaverLog();


      if (!ILWeaverSettings.ValidateConfig(out var status, out var readException)) {
        string message;
        DiagnosticType messageType;

        switch (status) {
          case ILWeaverSettings.ConfigStatus.NotFound: {

              var candidates = Directory.GetFiles("Assets", "*.fusion", SearchOption.AllDirectories);

              message = $"Fusion ILWeaver config error: {nameof(NetworkProjectConfig)} not found at {ILWeaverSettings.NetworkProjectConfigPath}. " +
                $"Implement {nameof(ILWeaverSettings)}.OverrideNetworkProjectConfigPath in Fusion.CodeGen.User.cs to change the config's location.";

              if (candidates.Any()) {
                message += $" Possible candidates are: {(string.Join(", ", candidates))}.";
              }

              messageType = DiagnosticType.Warning;
            }
            break;

          case ILWeaverSettings.ConfigStatus.ReadException:
            message = $"Fusion ILWeaver config error: reading file {ILWeaverSettings.NetworkProjectConfigPath} failed: {readException.Message}";
            messageType = DiagnosticType.Error;
            break;

          default:
            throw new NotSupportedException(status.ToString());
        }

        return new ILPostProcessResult(null, new List<DiagnosticMessage>() {
          new DiagnosticMessage() {
            DiagnosticType = messageType,
            MessageData = message,
          }
        }
        );
      }

      using (log.Scope($"Process {compiledAssembly.Name}")) {
        InMemoryAssembly resultAssembly = null;

        try {
          ILWeaverAssembly asm;
          ILWeaver weaver;

          using (log.Scope("Resolving")) {
            asm = CreateWeaverAssembly(log, compiledAssembly);
          }

          using (log.Scope("Init")) { 
            weaver = new ILWeaver(log);
          }

          weaver.Weave(asm);

          if (asm.Modified) {
            var pe = new MemoryStream();
            var pdb = new MemoryStream();
            var writerParameters = new WriterParameters {
              SymbolWriterProvider = new PortablePdbWriterProvider(),
              SymbolStream = pdb,
              WriteSymbols = true
            };

            using (log.Scope("Writing")) {
              asm.CecilAssembly.Write(pe, writerParameters);
              resultAssembly = new InMemoryAssembly(pe.ToArray(), pdb.ToArray());
            }
          }
        } catch (Exception ex) {
          log.Error($"Exception thrown when weaving {compiledAssembly.Name}");
          log.Exception(ex);
        } finally {
          log.FixNewLinesInMessages();
          result = new ILPostProcessResult(resultAssembly, log.Messages);
        }
      }

      return result;
    }


    public override bool WillProcess(ICompiledAssembly compiledAssembly) {

      if (!ILWeaverSettings.ValidateConfig(out _, out _)) {
        // need to go to the next stage for some assembly, main is good enough
        return compiledAssembly.Name == "Assembly-CSharp";
      }

      if (!ILWeaverSettings.IsAssemblyWeavable(compiledAssembly.Name)) {
        return false;
      }

      if (!ILWeaverSettings.ContainsRequiredReferences(compiledAssembly.References)) {
        return false;
      }

      return true;
    }

    class ReflectionImporterProvider : IReflectionImporterProvider {
      private ILWeaverLog _log;

      public ReflectionImporterProvider(ILWeaverLog log) {
        _log = log;
      }
      
      public IReflectionImporter GetReflectionImporter(ModuleDefinition module) {
        return new ReflectionImporter(_log, module);
      }
    }

    class ReflectionImporter : DefaultReflectionImporter {
      private ILWeaverLog _log;
      
      public ReflectionImporter(ILWeaverLog log, ModuleDefinition module) : base(module) {
        _log = log;
      }

      public override AssemblyNameReference ImportReference(AssemblyName name) {
        if (name.Name == "System.Private.CoreLib") {
          // seems weaver is run with .net core,  but we need to stick to .net framework
          var candidates = module.AssemblyReferences
            .Where(x => x.Name == "mscorlib" || x.Name == "netstandard")
            .OrderBy(x => x.Name)
            .ThenByDescending(x => x.Version)
            .ToList();

          // in Unity 2020.1 and .NET 4.x mode when building with IL2CPP apparently both mscrolib and netstandard can be loaded
          if (candidates.Count > 0) {
            return candidates[0];
          }
          
          throw new ILWeaverException("Could not locate mscrolib or netstandard assemblies");
        }
        
        return base.ImportReference(name);
      }
    }
  }
#else
  class ILWeaverBindings : ILPostProcessor {
    public override ILPostProcessor GetInstance() {
      return this;
    }

    public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly) {
      return new ILPostProcessResult(null, new List<DiagnosticMessage>() {
        new DiagnosticMessage() {
          DiagnosticType = DiagnosticType.Warning,
          MessageData = "Mono.Cecil not found, Fusion IL weaving is disabled. Make sure package com.unity.nuget.mono-cecil is installed."
        }
      });
    }

    public override bool WillProcess(ICompiledAssembly compiledAssembly) {
      return compiledAssembly.Name == "Assembly-CSharp";
    }
  }
#endif
#else
  class ILWeaverBindings : ILPostProcessor {
    public override ILPostProcessor GetInstance() {
      return this;
    }

    public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly) {
      throw new NotImplementedException();
    }

    public override bool WillProcess(ICompiledAssembly compiledAssembly) {
      return false;
    }
  }
#endif
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverBindings.UnityEditor.cs

#if FUSION_WEAVER && !FUSION_WEAVER_ILPOSTPROCESSOR

namespace Fusion.CodeGen {
#if FUSION_HAS_MONO_CECIL
  using System;
  using System.Collections.Generic;
  using System.Diagnostics;
  using System.IO;
  using System.Linq;
  using Mono.Cecil;
  using UnityEditor;
  using UnityEditor.Build;
  using UnityEditor.Build.Reporting;
  using UnityEditor.Compilation;
  using CompilerAssembly = UnityEditor.Compilation.Assembly;

  class ILWeaverBindings {

    static ILWeaver _weaver;


    [UnityEditor.InitializeOnLoadMethod]
    public static void InitializeOnLoad() {
      CompilationPipeline.assemblyCompilationFinished += OnCompilationFinished;
      EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
    }

    static void OnPlayModeStateChanged(PlayModeStateChange state) {
      var projectConfig = NetworkProjectConfig.Global;

      // exit edit mode means play mode is about to start ...
      if (state == PlayModeStateChange.ExitingEditMode) {
        foreach (var assembly in CompilationPipeline.GetAssemblies()) {
          var name = Path.GetFileNameWithoutExtension(assembly.outputPath);
          if (ILWeaverSettings.IsAssemblyWeavable(name)) {
            OnCompilationFinished(assembly.outputPath, new CompilerMessage[0]);
          }
        }
      }
    }

    static void OnCompilationFinished(string path, CompilerMessage[] messages) {
#if FUSION_DEV
      Stopwatch sw = Stopwatch.StartNew();
      Log.Debug($"OnCompilationFinished({path})");
#endif

      // never modify editor assemblies
      if (ILWeaver.IsEditorAssemblyPath(path)) {
        return;
      }

      var projectConfig = NetworkProjectConfig.Global;
      if (projectConfig != null) {
        // name of assembly on disk
        var name = Path.GetFileNameWithoutExtension(path);
        if (!ILWeaverSettings.IsAssemblyWeavable(name)) {
          return;
        }
      }

      // errors means we should exit
      if (messages.Any(x => x.type == CompilerMessageType.Error)) {
#if FUSION_DEV
        Log.Error($"Can't execute ILWeaver on {path}, compilation errors exist.");
#endif
        return;
      }

      // grab compiler pipe assembly
      var asm = CompilationPipeline.GetAssemblies().First(x => x.outputPath == path);

      // needs to reference phoenix runtime
      if (ILWeaverSettings.ContainsRequiredReferences(asm.allReferences) == false) {
        return;
      }

      // perform weaving
      try {
        _weaver = _weaver ?? new ILWeaver(new ILWeaverLog());
        Weave(_weaver, asm);
      } catch (Exception ex) {
        UnityEngine.Debug.LogError(ex);
      }

#if FUSION_DEV
      UnityEngine.Debug.Log($"OnCompilationFinished took: {sw.Elapsed}");
#endif
    }


    static void Weave(ILWeaver weaver, Assembly compilerAssembly) {
      using (weaver.Log.Scope("Processing")) {

        using (var resolver = new ILWeaverAssemblyResolver()) {
          // if we're already weaving this don't do anything
          if (resolver.Contains(compilerAssembly)) {
            return;
          }

          // make sure we can load all dlls
          foreach (string path in compilerAssembly.allReferences) {
            resolver.AddSearchDirectory(Path.GetDirectoryName(path));
          }

          // make sure we have the runtime dll loaded
          if (!ILWeaverSettings.ContainsRequiredReferences(compilerAssembly.allReferences)) {
            throw new InvalidOperationException($"Weaving: Could not find required assembly references");
          }

          ILWeaverAssembly asm;

          using (weaver.Log.Scope("Resolving")) {
            asm = resolver.AddAssembly(compilerAssembly);
          }

          if (weaver.Weave(asm)) {

            using (weaver.Log.Scope("Writing")) {
              // write asm to disk
              asm.CecilAssembly.Write(new WriterParameters {
                WriteSymbols = true
              });
            }
          }
        }
      }
    }
  }
#else
  class ILWeaverBindings {
    [UnityEditor.InitializeOnLoadMethod]
    public static void InitializeOnLoad() {
      UnityEngine.Debug.LogError("Mono.Cecil not found, Fusion IL weaving is disabled. Make sure package com.unity.nuget.mono-cecil is installed.");
    }
  }
#endif
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverException.cs

namespace Fusion.CodeGen {
  using System;
  using System.Diagnostics;

  public class ILWeaverException : Exception {
    public ILWeaverException(string error) : base(error) {
    }

    public ILWeaverException(string error, Exception innerException) : base(error, innerException) {
    }


    [Conditional("UNITY_EDITOR")]
    public static void DebugThrowIf(bool condition, string message) {
      if (condition) {
        throw new ILWeaverException(message);
      }
    }
  }
}

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverExtensions.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL
namespace Fusion.CodeGen {

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Runtime.CompilerServices;
  using System.Text;
  using System.Text.RegularExpressions;
  using System.Threading.Tasks;
  using Mono.Cecil;
  using Mono.Cecil.Cil;
  using Mono.Cecil.Rocks;

  public static class ILWeaverExtensions {

    public static bool IsIntegral(this TypeReference type) {
      switch (type.MetadataType) {
        case MetadataType.Byte:
        case MetadataType.SByte:
        case MetadataType.UInt16:
        case MetadataType.Int16:
        case MetadataType.UInt32:
        case MetadataType.Int32:
        case MetadataType.UInt64:
        case MetadataType.Int64:
          return true;
        default:
          return false;
      }
    }

    public static int GetPrimitiveSize(this TypeReference type) {
      switch (type.MetadataType) {
        case MetadataType.Byte:
        case MetadataType.SByte:
          return sizeof(byte);
        case MetadataType.UInt16:
        case MetadataType.Int16:
          return sizeof(short);
        case MetadataType.UInt32:
        case MetadataType.Int32:
          return sizeof(int);
        case MetadataType.UInt64:
        case MetadataType.Int64:
          return sizeof(long);
        case MetadataType.Single:
          return sizeof(float);
        case MetadataType.Double:
          return sizeof(double);
        default:
          throw new ArgumentException($"Unknown primitive type: {type}", nameof(type));
      }
    }

    public static bool IsString(this TypeReference type) {
      return type.MetadataType == MetadataType.String;
    }

    public static bool IsFloat(this TypeReference type) {
      return type.MetadataType == MetadataType.Single;
    }

    public static bool IsBool(this TypeReference type) {
      return type.MetadataType == MetadataType.Boolean;
    }

    public static bool IsVector2(this TypeReference type) {
      return type.FullName == typeof(UnityEngine.Vector2).FullName;
    }

    public static bool IsVector3(this TypeReference type) {
      return type.FullName == typeof(UnityEngine.Vector3).FullName;
    }

    public static bool IsQuaternion(this TypeReference type) {
      return type.FullName == typeof(UnityEngine.Quaternion).FullName;
    }

    public static bool IsVoid(this TypeReference type) {
      return type.MetadataType == MetadataType.Void;
    }

    public static TypeReference GetElementTypeEx(this TypeReference type) {
      if (type.IsPointer) {
        return ((Mono.Cecil.PointerType)type).ElementType;
      } else if (type.IsByReference) {
        return ((Mono.Cecil.ByReferenceType)type).ElementType;
      } else {
        return type.GetElementType();
      }
    }

    public static bool IsSubclassOf<T>(this TypeReference type) {
      return !IsSame<T>(type) && Is<T>(type);
    }

    public static bool IsGeneric(this TypeReference type, Type typeDefinition) {
      if (typeDefinition.IsGenericTypeDefinition == false) {
        throw new InvalidOperationException();
      }
      if (!type.IsGenericInstance) {
        return false;
      }

      return type.GetElementType().FullName == typeDefinition.FullName;
    }

    public static bool IsNetworkList(this TypeReference type) {
      return IsNetworkList(type, out _);
    }
    
    public static bool IsNetworkList(this TypeReference type, out TypeReference elementType) {
      if (!type.IsGenericInstance || type.GetElementType().FullName != typeof(NetworkLinkedList<>).FullName) {
        elementType = default;
        return false;
      }

      var git = (GenericInstanceType)type;
      elementType = git.GenericArguments[0];
      return true;
    }


    public static bool IsNetworkArray(this TypeReference type) {
      return IsNetworkArray(type, out _);
    }

    public static bool IsNetworkArray(this TypeReference type, out TypeReference elementType) {
      if (!type.IsGenericInstance || type.GetElementType().FullName != typeof(NetworkArray<>).FullName) {
        elementType = default;
        return false;
      }

      var git = (GenericInstanceType)type;
      elementType = git.GenericArguments[0];
      return true;
    }


    public static bool IsNetworkDictionary(this TypeReference type) {
      return IsNetworkDictionary(type, out _, out _);
    }

    public static bool IsNetworkDictionary(this TypeReference type, out TypeReference keyType, out TypeReference valueType) {
      if (!type.IsGenericInstance || type.GetElementType().FullName != typeof(NetworkDictionary<,>).FullName) {
        keyType = default;
        valueType = default;
        return false;
      }

      var git = (GenericInstanceType)type;
      keyType = git.GenericArguments[0];
      valueType = git.GenericArguments[1];
      return true;
    }

    public static bool Is<T>(this TypeReference type) {
      return Is(type, typeof(T));
    }

    public static bool Is(this TypeReference type, Type t) {
      if (IsSame(type, t)) {
        return true;
      }

      var resolvedType = TryResolve(type);

      if (t.IsInterface) {
        if (resolvedType == null) {
          return false;
        }

        foreach (var interf in resolvedType.Interfaces) {
          if (interf.InterfaceType.IsSame(t)) {
            return true;
          }
        }
        return false;
      } else {
        if (resolvedType?.BaseType == null) {
          return false;
        }
        return Is(resolvedType.BaseType, t);
      }
    }

    public static bool Is(this TypeReference type, TypeReference t) {
      if (IsSame(type, t)) {
        return true;
      }

      var resolvedType = TryResolve(type);

      if (t.TryResolve()?.IsInterface == true) {
        if (resolvedType == null) {
          return false;
        }

        foreach (var interf in resolvedType.Interfaces) {
          if (interf.InterfaceType.IsSame(t)) {
            return true;
          }
        }
        return false;
      } else {
        if (resolvedType?.BaseType == null) {
          return false;
        }
        return Is(resolvedType.BaseType, t);
      }
    }

    public static bool IsSame<T>(this TypeReference type) {
      return IsSame(type, typeof(T));
    }

    public static bool IsSame(this TypeReference type, Type t) {
      if (type == null) {
        throw new ArgumentNullException(nameof(type));
      }
      if (type.IsByReference) {
        type = type.GetElementType();
      }
      if (type.IsVoid() && t == typeof(void)) {
        return true;
      }
      if (type.IsValueType != t.IsValueType) {
        return false;
      }
      if (type.FullName != t.FullName) {
        return false;
      }
      return true;
    }

    public static bool IsSame(this TypeReference type, TypeOrTypeRef t) {
      if (t.Type != null) {
        return IsSame(type, t.Type);
      } else if (t.TypeReference != null) {
        return IsSame(type, t.TypeReference);
      } else {
        throw new InvalidOperationException();
      }
    }

    public static bool IsSame(this TypeReference type, TypeReference t) {
      if (type == null) {
        throw new ArgumentNullException(nameof(type));
      }
      if (type.IsByReference) {
        type = type.GetElementType();
      }
      if (type.IsValueType != t.IsValueType) {
        return false;
      }
      if (type.FullName != t.FullName) {
        return false;
      }
      return true;
    }


    public static IEnumerable<TypeDefinition> GetHierarchy(this TypeDefinition type, TypeReference stopAtBaseType = null) {
      if (stopAtBaseType?.IsSame(type) == true) {
        yield break;
      }

      for (; ; ) {
        yield return type;
        if (type.BaseType == null || stopAtBaseType?.IsSame(type.BaseType) == true) {
          break;
        }
        type = type.BaseType.Resolve();
      }
    }

    public static TypeDefinition TryResolve(this TypeReference type) {
      try {
        return type.Resolve();
      } catch {
        return null;
      }
    }

    public static bool IsFixedBuffer(this TypeReference type, out int size) {
      size = default;
      if (!type.IsValueType) {
        return false;
      }

      if (!type.Name.EndsWith("e__FixedBuffer")) {
        return false;
      }

      var definition = TryResolve(type);
      if (definition == null) {
        return false;
      }

      // this is a bit of a guesswork
      if (HasAttribute<CompilerGeneratedAttribute>(definition) &&
          HasAttribute<UnsafeValueTypeAttribute>(definition) &&
          definition.ClassSize > 0) {
        size = definition.ClassSize;
        return true;
      }

      return false;
    }

    public static bool HasAttribute<T>(this ICustomAttributeProvider type) where T : Attribute {
      for (int i = 0; i < type.CustomAttributes.Count; ++i) {
        if (type.CustomAttributes[i].AttributeType.Name == typeof(T).Name) {
          return true;
        }
      }

      return false;
    }

    public static bool TryGetAttribute<T>(this ICustomAttributeProvider type, out CustomAttribute attribute) where T : Attribute {
      for (int i = 0; i < type.CustomAttributes.Count; ++i) {
        if (type.CustomAttributes[i].AttributeType.Name == typeof(T).Name) {
          attribute = type.CustomAttributes[i];
          return true;
        }
      }

      attribute = null;
      return false;
    }

    public static T GetAttributeArgument<T>(this CustomAttribute attr, int index) {
      return (T)attr.ConstructorArguments[index].Value;
    }

    public static bool TryGetAttributeArgument<T>(this CustomAttribute attr, int index, out T value, T defaultValue = default) {
      if (index < attr.ConstructorArguments.Count) {
        if (attr.ConstructorArguments[index].Value is T t) {
          value = t;
          return true;
        }
      }

      value = defaultValue;
      return false;
    }

    public static T GetAttributeProperty<T>(this CustomAttribute attr, string name, T defaultValue = default) {
      attr.TryGetAttributeProperty(name, out var result, defaultValue);
      return result;
    }

    public static bool TryGetAttributeProperty<T>(this CustomAttribute attr, string name, out T value, T defaultValue = default) {
      if (attr.HasProperties) {
        var prop = attr.Properties.FirstOrDefault(x => x.Name == name);

        if (prop.Argument.Value != null) {
          value = (T)prop.Argument.Value;
          return true;
        }
      }

      value = defaultValue;
      return false;
    }

    static bool TryGetMatchingMethod(IEnumerable<MethodDefinition> methods, IList<ParameterDefinition> parameters, out MethodDefinition result) {
      foreach (var c in methods) {
        if (c.Parameters.Count != parameters.Count) {
          continue;
        }
        int i;
        for (i = 0; i < c.Parameters.Count; ++i) {
          if (!c.Parameters[i].ParameterType.IsSame(parameters[i].ParameterType)) {
            break;
          }
        }

        if (i == c.Parameters.Count) {
          result = c;
          return true;
        }
      }

      result = null;
      return false;
    }

    public static bool TryGetMatchingConstructor(this TypeDefinition type, MethodDefinition constructor, out MethodDefinition matchingConstructor) {
      return TryGetMatchingMethod(type.GetConstructors(), constructor.Parameters, out matchingConstructor);
    }

    public static bool TryGetMethod(this TypeDefinition type, string methodName, IList<ParameterDefinition> parameters, out MethodDefinition method) {
      var methods = type.Methods.Where(x => x.Name == methodName);
      
      if (TryGetMatchingMethod(methods, parameters, out method)) {
        return true;
      }

      //if (type.BaseType != null) {
      //  if (stopAtBaseType == null || !stopAtBaseType.IsSame(type.BaseType)) {
      //    return TryGetMethod(type.BaseType.Resolve(), methodName, parameters, out method, stopAtBaseType);
      //  }
      //}

      method = null;
      return false;
    }

    public static bool Remove(this FieldDefinition field) {
      return field.DeclaringType.Fields.Remove(field);
    }

    public static FieldDefinition GetFieldOrThrow(this TypeDefinition type, string fieldName) {
      foreach (var field in type.Fields) {
        if ( field.Name == fieldName ) {
          return field;
        }
      }
      throw new ArgumentOutOfRangeException(nameof(fieldName), $"Field {fieldName} not found in {type}");
    }

    public static MethodReference GetGenericInstanceMethodOrThrow(this GenericInstanceType type, string name) {
      var methodRef = type.Resolve().GetMethodOrThrow(name);

      var newMethodRef = new MethodReference(methodRef.Name, methodRef.ReturnType) {
        HasThis = methodRef.HasThis,
        ExplicitThis = methodRef.ExplicitThis,
        DeclaringType = type,
        CallingConvention = methodRef.CallingConvention,
      };

      foreach (var parameter in methodRef.Parameters) {
        newMethodRef.Parameters.Add(new ParameterDefinition(parameter.Name, parameter.Attributes, parameter.ParameterType));
      }

      foreach (var genericParameter in methodRef.GenericParameters) {
        newMethodRef.GenericParameters.Add(new GenericParameter(genericParameter.Name, newMethodRef));
      }

      return newMethodRef;
    }

    public static void AddInterface<T>(this TypeDefinition type, ILWeaverAssembly asm) {
      type.Interfaces.Add(new InterfaceImplementation(asm.Import(typeof(T))));
    }

    public static bool RemoveAttribute<T>(this IMemberDefinition member, ILWeaverAssembly asm) where T : Attribute {
      for (int i = 0; i < member.CustomAttributes.Count; ++i) {
        var attr = member.CustomAttributes[i];
        if ( attr.AttributeType.Is<T>() ) {
          member.CustomAttributes.RemoveAt(i);
          return true;
        }
      }
      return false;
    }

    public static CustomAttribute AddAttribute<T>(this IMemberDefinition member, ILWeaverAssembly asm) where T : Attribute {
      CustomAttribute attr;
      attr = new CustomAttribute(typeof(T).GetConstructor(asm));
      member.CustomAttributes.Add(attr);
      return attr;
    }

    public static CustomAttribute AddAttribute<T, A0>(this IMemberDefinition member, ILWeaverAssembly asm, A0 arg0) where T : Attribute {
      CustomAttribute attr;
      attr = new CustomAttribute(typeof(T).GetConstructor(asm, 1));
      attr.ConstructorArguments.Add(new CustomAttributeArgument(asm.ImportAttributeType<A0>(), arg0));
      member.CustomAttributes.Add(attr);
      return attr;
    }

    public static CustomAttribute AddAttribute<T, A0, A1>(this IMemberDefinition member, ILWeaverAssembly asm, A0 arg0, A1 arg1) where T : Attribute {
      CustomAttribute attr;
      attr = new CustomAttribute(typeof(T).GetConstructor(asm, 2));
      attr.ConstructorArguments.Add(new CustomAttributeArgument(asm.ImportAttributeType<A0>(), arg0));
      attr.ConstructorArguments.Add(new CustomAttributeArgument(asm.ImportAttributeType<A1>(), arg1));
      member.CustomAttributes.Add(attr);
      return attr;
    }

    public static CustomAttribute AddAttribute<T, A0, A1, A2>(this IMemberDefinition member, ILWeaverAssembly asm, A0 arg0, A1 arg1, A2 arg2) where T : Attribute {
      CustomAttribute attr;
      attr = new CustomAttribute(typeof(T).GetConstructor(asm, 3));
      attr.ConstructorArguments.Add(new CustomAttributeArgument(asm.ImportAttributeType<A0>(), arg0));
      attr.ConstructorArguments.Add(new CustomAttributeArgument(asm.ImportAttributeType<A1>(), arg1));
      attr.ConstructorArguments.Add(new CustomAttributeArgument(asm.ImportAttributeType<A2>(), arg2));
      member.CustomAttributes.Add(attr);
      return attr;
    }

    private static TypeReference ImportAttributeType<T>(this ILWeaverAssembly asm) {
      if (typeof(T) == typeof(TypeReference)) {
        return asm.Import<Type>();
      } else {
        return asm.Import<T>();
      }
    }

    public static MethodReference GetConstructor(this Type type, ILWeaverAssembly asm, int argCount = 0) {
      foreach (var ctor in type.GetConstructors()) {
        if (ctor.GetParameters().Length == argCount) {
          return asm.CecilAssembly.MainModule.ImportReference(ctor);
        }
      }

      throw new ILWeaverException($"Could not find constructor with {argCount} arguments on {type.Name}");
    }

    public static void AddTo(this MethodDefinition method, TypeDefinition type) {
      type.Methods.Add(method);
    }

    public static void AddTo(this PropertyDefinition property, TypeDefinition type) {
      type.Properties.Add(property);
    }


    public static void AddTo(this FieldDefinition field, TypeDefinition type) {
      type.Fields.Add(field);
    }

    public static void AddTo(this TypeDefinition type, AssemblyDefinition assembly) {
      assembly.MainModule.Types.Add(type);
    }

    public static void AddTo(this TypeDefinition type, TypeDefinition parentType) {
      parentType.NestedTypes.Add(type);
    }

    public static MethodDefinition GetMethodOrThrow(this TypeDefinition type, string methodName) {
      foreach (var method in type.Methods) {
        if (method.Name == methodName) {
          return method;
        }
      }
      throw new ArgumentOutOfRangeException(nameof(methodName), $"Method {methodName} not found in {type}");
    }

    public static Instruction AppendReturn(this ILProcessor il, Instruction instruction) {
      il.Append(instruction);
      return instruction;
    }

    public static void Clear(this ILProcessor il) {
      var instructions = il.Body.Instructions;
      foreach (var instruction in instructions.Reverse()) {
        il.Remove(instruction);
      }
    }

    public static MethodDefinition AddEmptyConstructor(this TypeDefinition type, ILWeaverAssembly asm) {
      var methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName;
      var method = new MethodDefinition(".ctor", methodAttributes, asm.Import(typeof(void)));
      method.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));

      MethodReference baseConstructor;

      if (type.BaseType.IsGenericInstance) {
        var gi = (GenericInstanceType)type.BaseType;
        baseConstructor = gi.GetGenericInstanceMethodOrThrow(".ctor");
      } else {
        if (!type.BaseType.Resolve().TryGetMatchingConstructor(method, out var baseConstructorDef)) {
          throw new ILWeaverException("Unable to find matching constructor.");
        }
        baseConstructor = baseConstructorDef;
      }

      

      method.Body.Instructions.Add(Instruction.Create(OpCodes.Call, asm.Import(baseConstructor)));
      method.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
      type.Methods.Add(method);
      return method;
    }

    public static void AppendMacro<T>(this ILProcessor il, in T macro) where T : struct, ILProcessorMacro {
      macro.Emit(il);
    }

    public class TypeOrTypeRef {

      public Type Type { get; }
      public TypeReference TypeReference { get; }


      public TypeOrTypeRef(Type type, bool isOut = false) {
        Type = type;
      }

      public TypeOrTypeRef(TypeReference type, bool isOut = false) {
        TypeReference = type;
      }

      public static implicit operator TypeOrTypeRef(Type type) {
        return new TypeOrTypeRef(type);
      }

      public static implicit operator TypeOrTypeRef(TypeReference type) {
        return new TypeOrTypeRef(type);
      }

      public override string ToString() {
        if (Type != null) {
          return Type.FullName;
        } else if (TypeReference != null) {
          return TypeReference.ToString();
        } else {
          return "AnyType";
        }
      }
    }


    public static bool GetSingleOrDefaultMethodWithAttribute<T>(this TypeDefinition type, out CustomAttribute attribute, out MethodDefinition method) where T : Attribute {

      MethodDefinition resultMethod = null;
      CustomAttribute resultAttribute = null;

      foreach (var m in type.Methods) {
        if (m.TryGetAttribute<T>(out var attr)) {
          if (resultMethod != null) {
            throw new ILWeaverException($"Only one method with attribute {typeof(T)} allowed per class: {type}");
          } else {
            resultMethod = m;
            resultAttribute = attr;
          }
        }
      }

      method = resultMethod;
      attribute = resultAttribute;
      return method != null;
    }


    public static PropertyDefinition ThrowIfStatic(this PropertyDefinition property) {
      if (property.GetMethod?.IsStatic == true ||
          property.SetMethod?.IsStatic == true) {
        throw new ILWeaverException($"Property is static: {property.FullName}");
      }
      return property;
    }

    public static MethodDefinition ThrowIfStatic(this MethodDefinition method) {
      if (method.IsStatic) {
        throw new ILWeaverException($"Method is static: {method.FullName}");
      }
      return method;
    }

    public static MethodDefinition ThrowIfNotStatic(this MethodDefinition method) {
      if (!method.IsStatic) {
        throw new ILWeaverException($"Method is not static: {method}");
      }
      return method;
    }

    public static MethodDefinition ThrowIfNotPublic(this MethodDefinition method) {
      if (!method.IsPublic) {
        throw new ILWeaverException($"Method is not public: {method}");
      }
      return method;
    }

    public static MethodDefinition ThrowIfReturnType(this MethodDefinition method, TypeOrTypeRef type) {
      if (!method.ReturnType.IsSame(type)) {

        throw new ILWeaverException($"Method has an invalid return type (expected {type}): {method}");
      }
      return method;
    }

    public static MethodDefinition ThrowIfParameterCount(this MethodDefinition method, int count) {
      if (method.Parameters.Count != count) {
        throw new ILWeaverException($"Method has invalid parameter count (expected {count}): {method}");
      }
      return method;
    }

    public static MethodDefinition ThrowIfParameter(this MethodDefinition method, int index, TypeOrTypeRef type = null, bool isByReference = false) {
      var p = method.Parameters[index];
      if (type != null && !p.ParameterType.IsSame(type)) {
        throw new ILWeaverException($"Parameter {p} ({index}) has an invalid type (expected {type}): {method}");
      }
      if (p.ParameterType.IsByReference != isByReference) {
        if (p.IsOut) {
          throw new ILWeaverException($"Parameter {p} ({index}) is a ref parameter: {method}");
        } else {
          throw new ILWeaverException($"Parameter {p} ({index}) is not a ref parameter: {method}");
        }
      }
      return method;
    }

    public static bool IsBaseConstructorCall(this Instruction instruction, TypeDefinition type) {
      if (instruction.OpCode == OpCodes.Call) {
        var m = ((MethodReference)instruction.Operand).Resolve();
        if (m.IsConstructor && m.DeclaringType.IsSame(type.BaseType)) {
          // base constructor init
          return true;
        }
      }
      return false;
    }

    public static bool IsLdloca(this Instruction instruction, out VariableDefinition variable, out bool isShort) {
      if (instruction.OpCode == OpCodes.Ldloca) {
        variable = (VariableDefinition)instruction.Operand;
        isShort = false;
        return true;
      }
      if (instruction.OpCode == OpCodes.Ldloca_S) {
        variable = (VariableDefinition)instruction.Operand;
        isShort = true;
        return true;
      }

      variable = default;
      isShort = default;
      return false;
    }

    public static bool IsLdlocWithIndex(this Instruction instruction, out int index) {
      if (instruction.OpCode == OpCodes.Ldloc_0) {
        index = 0;
        return true;
      }
      if (instruction.OpCode == OpCodes.Ldloc_1) {
        index = 1;
        return true;
      }
      if (instruction.OpCode == OpCodes.Ldloc_2) {
        index = 2;
        return true;
      }
      if (instruction.OpCode == OpCodes.Ldloc_3) {
        index = 3;
        return true;
      }
      index = -1;
      return false;
    }

    public static bool IsStlocWithIndex(this Instruction instruction, out int index) {
      if (instruction.OpCode == OpCodes.Stloc_0) {
        index = 0;
        return true;
      }
      if (instruction.OpCode == OpCodes.Stloc_1) {
        index = 1;
        return true;
      }
      if (instruction.OpCode == OpCodes.Stloc_2) {
        index = 2;
        return true;
      }
      if (instruction.OpCode == OpCodes.Stloc_3) {
        index = 3;
        return true;
      }
      index = -1;
      return false;
    }
  }

  public interface ILProcessorMacro {
    void Emit(ILProcessor il);
  }
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverLog.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL

namespace Fusion.CodeGen {

  using System;
  using System.Diagnostics;
  using System.Runtime.CompilerServices;
  using Mono.Cecil;
  using UnityEngine;

  public partial class ILWeaverLog {

    public void AssertMessage(bool condition, string message, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      if (!condition) {
        AssertFailed("Assert failed: " + message, filePath, lineNumber);
      }
    }


    public void Assert(bool condition, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      if (!condition) {
        AssertFailed("Assertion failed", filePath, lineNumber);
      }
    }

    [Conditional("FUSION_WEAVER_DEBUG")]
    public void Debug(string message, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      Log(LogType.Log, message, filePath, lineNumber);
    }

    public void Warn(string message, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      Log(LogType.Warning, message, filePath, lineNumber);
    }

    public void Error(string message, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      Log(LogType.Error, message, filePath, lineNumber);
    }

    public void Exception(Exception ex) {
      LogExceptionImpl(ex);
    }

    partial void AssertFailed(string message, string filePath, int lineNumber);

    private void Log(LogType logType, string message, string filePath, int lineNumber) {
      LogImpl(logType, message, filePath, lineNumber);
    }

    partial void LogImpl(LogType logType, string message, string filePath, int lineNumber);
    partial void LogExceptionImpl(Exception ex);

#if !FUSION_WEAVER_DEBUG
    public struct LogScope : IDisposable {
      public void Dispose() {
      }
    }

    public LogScope Scope(string name) {
      return default;
    }

    public LogScope ScopeAssembly(AssemblyDefinition cecilAssembly) {
      return default;
    }

    public LogScope ScopeBehaviour(TypeDefinition type) {
      return default;
    }

    public LogScope ScopeInput(TypeDefinition type) {
      return default;
    }

    public LogScope ScopeStruct(TypeDefinition type) {
      return default;
    }

#else
    public LogScope Scope(string name, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      return new LogScope(this, name, filePath, lineNumber);
    }

    public LogScope ScopeAssembly(AssemblyDefinition cecilAssembly, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      return new LogScope(this, $"Assembly: {cecilAssembly.FullName}", filePath, lineNumber);
    }

    public LogScope ScopeBehaviour(TypeDefinition type, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      return new LogScope(this, $"Behaviour: {type.FullName}", filePath, lineNumber);
    }

    public LogScope ScopeInput(TypeDefinition type, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      return new LogScope(this, $"Input: {type.FullName}", filePath, lineNumber);
    }

    public LogScope ScopeStruct(TypeDefinition type, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) {
      return new LogScope(this, $"Struct: {type.FullName}", filePath, lineNumber);
    }


    partial void ScopeBeginImpl(ref LogScope scope, string filePath, int lineNumber);
    partial void ScopeEndImpl(ref LogScope scope);


#pragma warning disable CS0282 // There is no defined ordering between fields in multiple declarations of partial struct
    public partial struct LogScope : IDisposable {
#pragma warning restore CS0282 // There is no defined ordering between fields in multiple declarations of partial struct
      public string Message;

      public TimeSpan Elapsed => _stopwatch.Elapsed;

      private ILWeaverLog _log;
      private Stopwatch _stopwatch;

      public LogScope(ILWeaverLog log, string message, [CallerFilePath] string filePath = null, [CallerLineNumber] int lineNumber = default) : this() {
        _log = log;
        Message = message;
        _stopwatch = Stopwatch.StartNew();
        _log.ScopeBeginImpl(ref this, filePath, lineNumber);
      }

      public void Dispose() {
        _stopwatch.Stop();
        _log.ScopeEndImpl(ref this);
      }

      partial void Init(string filePath, int lineNumber);
    }
#endif
  }
}

#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverLog.ILPostProcessor.cs

#if FUSION_WEAVER && FUSION_WEAVER_ILPOSTPROCESSOR && FUSION_HAS_MONO_CECIL

namespace Fusion.CodeGen {
  using System;
  using System.Collections.Generic;
  using Unity.CompilationPipeline.Common.Diagnostics;
  using UnityEngine;

  partial class ILWeaverLog {

    public List<DiagnosticMessage> Messages { get; } = new List<DiagnosticMessage>();

    partial void LogImpl(LogType logType, string message, string filePath, int lineNumber) {

      DiagnosticType diagnosticType;

      if (logType == LogType.Log) {
        // there are no debug diagnostic messages, make pretend warnings
        message = $"DEBUG: {message}";
        diagnosticType = DiagnosticType.Warning;
      } else if (logType == LogType.Warning) {
        diagnosticType = DiagnosticType.Warning;
      } else {
        diagnosticType = DiagnosticType.Error;
      }

      // newlines in messagedata will need to be escaped, but let's not slow things down now
      Messages.Add(new DiagnosticMessage() {
        File = filePath,
        Line = lineNumber,
        DiagnosticType = diagnosticType,
        MessageData = message
      });
    }

    partial void AssertFailed(string message, string filePath, int lineNumber) {
      Error(message, filePath, lineNumber);
      throw new AssertException();
    }

    partial void LogExceptionImpl(Exception ex) {
      var lines = ex.ToString().Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
      foreach (var line in lines) {
        Error(line, null, 0);
      }
    }

    public void FixNewLinesInMessages() {
      // fix the messages
      foreach (var msg in Messages) {
        msg.MessageData = msg.MessageData.Replace('\r', ';').Replace('\n', ';');
      }
    }



#if FUSION_WEAVER_DEBUG
#pragma warning disable CS0282 // There is no defined ordering between fields in multiple declarations of partial struct
    partial struct LogScope {
#pragma warning restore CS0282 // There is no defined ordering between fields in multiple declarations of partial struct
      public int LineNumber;
      public string FilePath;
    }

    partial void ScopeBeginImpl(ref LogScope scope, string filePath, int lineNumber) {
      scope.FilePath = filePath;
      scope.LineNumber = lineNumber;
      Log(LogType.Log, $"{scope.Message} start", scope.FilePath, scope.LineNumber);
    }

    partial void ScopeEndImpl(ref LogScope scope) {
      Log(LogType.Log, $"{scope.Message} end {scope.Elapsed}", scope.FilePath, scope.LineNumber);
    }
#endif
  }

}

#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverLog.UnityEditor.cs

#if FUSION_WEAVER && !FUSION_WEAVER_ILPOSTPROCESSOR && FUSION_HAS_MONO_CECIL

namespace Fusion.CodeGen {

  using UnityEngine;
  using System;

  partial class ILWeaverLog {

#if FUSION_WEAVER_DEBUG
    partial void LogExceptionImpl(Exception ex) {
      UnityEngine.Debug.unityLogger.LogException(ex);
    }

    partial void LogImpl(LogType logType, string message, string filePath, int lineNumber) {
      UnityEngine.Debug.unityLogger.Log(logType, message);
    }

    partial void ScopeBeginImpl(ref LogScope scope, string filePath, int lineNumber) {
      Log(LogType.Log, $"{scope.Message} start", default, default);
    }

    partial void ScopeEndImpl(ref LogScope scope) {
      Log(LogType.Log, $"{scope.Message} end {scope.Elapsed}", default, default);
    }

    partial void AssertFailed(string message, string filePath, int lineNumber) {
      Error(message, filePath, lineNumber);
      throw new AssertException();
    }
#endif
  }
}

#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverMethodContext.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL

namespace Fusion.CodeGen {

  using System;
  using System.Collections.Generic;
  using Mono.Cecil;
  using Mono.Cecil.Cil;
  using Mono.Cecil.Rocks;
  using static Fusion.CodeGen.ILWeaverOpCodes;

  unsafe partial class ILWeaver {

    ILMacroStruct AlignToWordSize() => new[] {
      Ldc_I4(Allocator.REPLICATE_WORD_SIZE - 1),
      Add(),
      Ldc_I4(~(Allocator.REPLICATE_WORD_SIZE - 1)),
      And()
    };

    ILMacroStruct LoadFixedBufferAddress(FieldDefinition fixedBufferField) => new Action<ILProcessor>(il => {

      var elementField = fixedBufferField.FieldType.Resolve().Fields[0];

      int pointerLoc = il.Body.Variables.Count;
      il.Body.Variables.Add(new VariableDefinition(elementField.FieldType.MakePointerType()));
      int pinnedRefLoc = il.Body.Variables.Count;
      il.Body.Variables.Add(new VariableDefinition(elementField.FieldType.MakeByReferenceType().MakePinnedType()));

      il.Append(Ldflda(fixedBufferField));
      il.Append(Ldflda(elementField));
      il.Append(Stloc(il.Body, pinnedRefLoc));
      il.Append(Ldloc(il.Body, pinnedRefLoc));
      il.Append(Conv_U());
      il.Append(Stloc(il.Body, pointerLoc));
      il.Append(Ldloc(il.Body, pointerLoc));
    });

    struct ILMacroStruct : ILProcessorMacro {
      Action<ILProcessor> generator;
      Instruction[] instructions;
      public static implicit operator ILMacroStruct(Instruction[] instructions) {
        return new ILMacroStruct() {
          instructions = instructions
        };
      }

      public static implicit operator ILMacroStruct(Action<ILProcessor> generator) {
        return new ILMacroStruct() {
          generator = generator
        };
      }

      public void Emit(ILProcessor il) {
        if (generator != null) {
          generator(il);
        } else {
          foreach (var instruction in instructions) {
            il.Append(instruction);
          }
        }
      }
    }

    class MethodContext : IDisposable {
      public readonly ILWeaverAssembly Assembly;
      public readonly MethodDefinition Method;

      private Dictionary<string, VariableDefinition> _fields = new Dictionary<string, VariableDefinition>();
      private Action<ILProcessor> addressGetter;
      private bool runnerIsLdarg0 = false;

      public MethodContext(ILWeaverAssembly assembly, MethodDefinition method, bool staticRunnerAccessor = false, Action<ILProcessor> addressGetter = null) {
        if (assembly == null) {
          throw new ArgumentNullException(nameof(assembly));
        }
        if (method == null) {
          throw new ArgumentNullException(nameof(method));
        }

        this.Assembly = assembly;
        this.Method = method;
        this.runnerIsLdarg0 = staticRunnerAccessor;
        this.addressGetter = addressGetter;
      }

      public void Dispose() {
      }

      public VariableDefinition GetOrCreateVariable(string id, TypeReference type) {
        if (_fields.TryGetValue(id, out var val)) {
          if (!val.VariableType.IsSame(type)) {
            throw new ArgumentException($"Variable of with the same name {id} already exists, but has a different type: {type} vs {val.VariableType}", nameof(id));
          }
          return val;
        }
        var result = new VariableDefinition(type);
        _fields.Add(id, result);
        Method.Body.Variables.Add(result);
        return result;
      }

      public TypeReference ImportReference(TypeReference type) {
        if (type == null) {
          throw new ArgumentNullException(nameof(type));
        }
        return Method.Module.ImportReference(type);
      }

      public MethodReference ImportReference(MethodReference method) {
        if (method == null) {
          throw new ArgumentNullException(nameof(method));
        }
        return Method.Module.ImportReference(method);
      }

      public virtual ILMacroStruct LoadAddress() => addressGetter;

      public ForLoopMacro For(int start, int stop, Action<ILProcessor, VariableDefinition> body) => new ForLoopMacro(this, body, start, stop);

      public AddOffsetMacro AddOffset(int val) => AddOffset(Ldc_I4(val));

      public AddOffsetMacro AddOffset(VariableDefinition val) => AddOffset(Ldloc(val));

      public AddOffsetMacro AddOffset(Instruction val) => new AddOffsetMacro(this, instruction: val);

      public AddOffsetMacro AddOffset(Action<ILProcessor> generator) => new AddOffsetMacro(this, generator: generator);

      public AddOffsetMacro AddOffset() => new AddOffsetMacro(this, null, null);

      public ScopeRpcOffset AddOffsetScope(ILProcessor il) => new ScopeRpcOffset(il, this);

      public ILMacroStruct LoadRunner() {
        return runnerIsLdarg0 ?
          new[] { Ldarg_0() } :
          new[] { Ldarg_0(), Ldfld(Assembly.SimulationBehaviour.GetField(nameof(SimulationBehaviour.Runner))) };
      }

      public virtual bool HasOffset => false;

      protected virtual void EmitAddOffsetBefore(ILProcessor il) {
      }

      protected virtual void EmitAddOffsetAfter(ILProcessor il) {
      }

      public readonly struct ForLoopMacro : ILProcessorMacro {
        public readonly MethodContext Context;
        public readonly Action<ILProcessor, VariableDefinition> Generator;
        public readonly int Start;
        public readonly int Stop;

        public ForLoopMacro(MethodContext context, Action<ILProcessor, VariableDefinition> generator, int start, int stop) {
          Context = context;
          Generator = generator;
          Start = start;
          Stop = stop;
        }

        public void Emit(ILProcessor il) {
          var body = Context.Method.Body;
          var varId = body.Variables.Count;
          var indexVariable = new VariableDefinition(Context.Assembly.Import(typeof(int)));
          body.Variables.Add(indexVariable);

          il.Append(Ldc_I4(Start));
          il.Append(Stloc(body, varId));

          var loopConditionStart = Ldloc(body, varId);
          il.Append(Br_S(loopConditionStart));
          {
            var loopBodyBegin = il.AppendReturn(Nop());
            Generator(il, indexVariable);

            il.Append(Ldloc(body, varId));
            il.Append(Ldc_I4(1));
            il.Append(Add());
            il.Append(Stloc(body, varId));

            il.Append(loopConditionStart);
            il.Append(Ldc_I4(Stop));
            il.Append(Blt_S(loopBodyBegin));
          }
        }
      }

      public readonly struct AddOffsetMacro : ILProcessorMacro {
        public readonly MethodContext Context;
        public readonly Instruction Instruction;
        public readonly Action<ILProcessor> Generator;

        public AddOffsetMacro(MethodContext context, Instruction instruction = null, Action<ILProcessor> generator = null) {
          Context = context;
          Instruction = instruction;
          Generator = generator;
        }

        public void Emit(ILProcessor il) {
          if (Context.HasOffset) {
            Context.EmitAddOffsetBefore(il);
            if (Instruction != null) {
              il.Append(Instruction);
            } else if (Generator != null) {
              Generator(il);
            }
            Context.EmitAddOffsetAfter(il);
          }
        }
      }

      public readonly struct ScopeRpcOffset : IDisposable {
        public readonly MethodContext context;
        public readonly ILProcessor il;

        public ScopeRpcOffset(ILProcessor il, MethodContext context) {
          this.context = context;
          this.il = il;
          if (context.HasOffset) {
            context.EmitAddOffsetBefore(il);
          }
        }

        public void Dispose() {
          if (context.HasOffset) {
            context.EmitAddOffsetAfter(il);
          }
        }
      }
    }

    class RpcMethodContext : MethodContext {
      public VariableDefinition DataVariable;
      public VariableDefinition OffsetVariable;
      public VariableDefinition RpcInvokeInfoVariable;

      public RpcMethodContext(ILWeaverAssembly asm, MethodDefinition definition, bool staticRunnerAccessor)
        : base(asm, definition, staticRunnerAccessor) {
      }

      public override bool HasOffset => true;

      protected override void EmitAddOffsetBefore(ILProcessor il) {
        il.Append(Ldloc(OffsetVariable));
      }

      protected override void EmitAddOffsetAfter(ILProcessor il) {
        il.Append(Add());
        il.Append(Stloc(OffsetVariable));
      }

      public override ILMacroStruct LoadAddress() => new[] {
        Ldloc(DataVariable),
        Ldloc(OffsetVariable),
        Add(),
      };

      public ILMacroStruct SetRpcInvokeInfoVariable(string name, Instruction value) => RpcInvokeInfoVariable == null ? new Instruction[0] :
        new[] {
           Ldloca(RpcInvokeInfoVariable),
           value,
           Stfld(Assembly.RpcInvokeInfo.GetField(name)),
        };

      public ILMacroStruct SetRpcInvokeInfoVariable(string name, int value) => RpcInvokeInfoVariable == null ? new Instruction[0] :
        new[] {
           Ldloca(RpcInvokeInfoVariable),
           Ldc_I4(value),
           Stfld(Assembly.RpcInvokeInfo.GetField(name)),
        };
      public ILMacroStruct SetRpcInvokeInfoStatus(bool emitIf, RpcLocalInvokeResult reason) => RpcInvokeInfoVariable == null || !emitIf ? new Instruction[0] :
        new[] {
           Ldloca(RpcInvokeInfoVariable),
           Ldc_I4((int)reason),
           Stfld(Assembly.RpcInvokeInfo.GetField(nameof(RpcInvokeInfo.LocalInvokeResult)))
        };

      public ILMacroStruct SetRpcInvokeInfoStatus(RpcSendCullResult reason) => RpcInvokeInfoVariable == null ? new Instruction[0] :
        new[] {
           Ldloca(RpcInvokeInfoVariable),
           Ldc_I4((int)reason),
           Stfld(Assembly.RpcInvokeInfo.GetField(nameof(RpcInvokeInfo.SendCullResult)))
        };

    }
  }
}

#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverOpCodes.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL
namespace Fusion.CodeGen {
  using System;
  using System.Diagnostics;

  using Mono.Cecil;
  using Mono.Cecil.Cil;

  static class ILWeaverOpCodes {
    // utils
    public static Instruction Nop()    => Instruction.Create(OpCodes.Nop);
    public static Instruction Ret()    => Instruction.Create(OpCodes.Ret);
    public static Instruction Dup()    => Instruction.Create(OpCodes.Dup);
    public static Instruction Pop()    => Instruction.Create(OpCodes.Pop);
    public static Instruction Ldnull() => Instruction.Create(OpCodes.Ldnull);
    public static Instruction Throw()  => Instruction.Create(OpCodes.Throw);

    public static Instruction Cast(TypeReference type) => Instruction.Create(OpCodes.Castclass, type);

    // breaks
    public static Instruction Brfalse(Instruction target)   => Instruction.Create(OpCodes.Brfalse, target);
    public static Instruction Brtrue(Instruction target)    => Instruction.Create(OpCodes.Brtrue, target);
    public static Instruction Brfalse_S(Instruction target) => Instruction.Create(OpCodes.Brfalse_S, target);
    public static Instruction Brtrue_S(Instruction target)  => Instruction.Create(OpCodes.Brtrue_S, target);
    public static Instruction Br_S(Instruction target)      => Instruction.Create(OpCodes.Br_S, target);
    public static Instruction Br(Instruction target)        => Instruction.Create(OpCodes.Br, target);
    public static Instruction Blt_S(Instruction target)     => Instruction.Create(OpCodes.Blt_S, target);
    public static Instruction Ble_S(Instruction target)     => Instruction.Create(OpCodes.Ble_S, target);
    public static Instruction Beq(Instruction target)       => Instruction.Create(OpCodes.Beq, target);
    public static Instruction Bne_Un_S(Instruction target)  => Instruction.Create(OpCodes.Bne_Un_S, target);
    public static Instruction Beq_S(Instruction target)     => Instruction.Create(OpCodes.Beq_S, target);

    // math
    public static Instruction Add() => Instruction.Create(OpCodes.Add);
    public static Instruction Sub() => Instruction.Create(OpCodes.Sub);
    public static Instruction Mul() => Instruction.Create(OpCodes.Mul);
    public static Instruction Div() => Instruction.Create(OpCodes.Div);
    public static Instruction And() => Instruction.Create(OpCodes.And);

    // obj
    public static Instruction Ldobj(TypeReference type) => Instruction.Create(OpCodes.Ldobj, type);
    public static Instruction Stobj(TypeReference type) => Instruction.Create(OpCodes.Stobj, type);

    public static Instruction Newobj(MethodReference constructor) => Instruction.Create(OpCodes.Newobj, constructor);

    public static Instruction Initobj(TypeReference type) => Instruction.Create(OpCodes.Initobj, type);

    // fields
    public static Instruction Ldflda(FieldReference field) => Instruction.Create(OpCodes.Ldflda, field);
    
    public static Instruction Ldfld(FieldReference  field) => Instruction.Create(OpCodes.Ldfld,  field);
    public static Instruction Stfld(FieldReference  field) => Instruction.Create(OpCodes.Stfld,  field);
    
    public static Instruction Ldsfld(FieldReference field) => Instruction.Create(OpCodes.Ldsfld, field);
    public static Instruction Stsfld(FieldReference field) => Instruction.Create(OpCodes.Stsfld, field);

    // locals

    public static Instruction Ldloc_or_const(VariableDefinition var, int val) => var != null ? Ldloc(var) : Ldc_I4(val);

    public static Instruction Ldloc(VariableDefinition var, MethodDefinition method) => Ldloc(method.Body, method.Body.Variables.IndexOf(var));

    public static Instruction Ldloc(VariableDefinition var)    => Instruction.Create(OpCodes.Ldloc, var);
    public static Instruction Ldloca(VariableDefinition var)   => Instruction.Create(OpCodes.Ldloca, var);
    public static Instruction Ldloca_S(VariableDefinition var) => Instruction.Create(OpCodes.Ldloca_S, var);
    public static Instruction Stloc(VariableDefinition var)    => Instruction.Create(OpCodes.Stloc, var);

    public static Instruction Stloc_0() => Instruction.Create(OpCodes.Stloc_0);
    public static Instruction Stloc_1() => Instruction.Create(OpCodes.Stloc_1);
    public static Instruction Stloc_2() => Instruction.Create(OpCodes.Stloc_2);
    public static Instruction Stloc_3() => Instruction.Create(OpCodes.Stloc_3);

    public static Instruction Ldloc_0() => Instruction.Create(OpCodes.Ldloc_0);
    public static Instruction Ldloc_1() => Instruction.Create(OpCodes.Ldloc_1);
    public static Instruction Ldloc_2() => Instruction.Create(OpCodes.Ldloc_2);
    public static Instruction Ldloc_3() => Instruction.Create(OpCodes.Ldloc_3);

    public static Instruction Stloc(MethodBody body, int index) {
      switch (index) {
        case 0:
          return Stloc_0();
        case 1:
          return Stloc_1();
        case 2:
          return Stloc_2();
        case 3:
          return Stloc_3();
        default:
          return Stloc(body.Variables[index]);
      }
    }

    public static Instruction Ldloc(MethodBody body, int index) {
      switch (index) {
        case 0:
          return Ldloc_0();
        case 1:
          return Ldloc_1();
        case 2:
          return Ldloc_2();
        case 3:
          return Ldloc_3();
        default:
          return Ldloc(body.Variables[index]);
      }
    }


    // ldarg
    public static Instruction Ldarg(ParameterDefinition arg) => Instruction.Create(OpCodes.Ldarg, arg);
    public static Instruction Ldarg_0() => Instruction.Create(OpCodes.Ldarg_0);
    public static Instruction Ldarg_1() => Instruction.Create(OpCodes.Ldarg_1);
    public static Instruction Ldarg_2() => Instruction.Create(OpCodes.Ldarg_2);
    public static Instruction Ldarg_3() => Instruction.Create(OpCodes.Ldarg_3);

    // starg

    public static Instruction Starg_S(ParameterDefinition arg) => Instruction.Create(OpCodes.Starg_S, arg);

    // array
    public static Instruction Ldlen()                    => Instruction.Create(OpCodes.Ldlen);

    public static Instruction Ldelem(TypeReference type) {
      switch (type.MetadataType) {
        case MetadataType.Byte:
          return Instruction.Create(OpCodes.Ldelem_U1);
        case MetadataType.SByte:
          return Instruction.Create(OpCodes.Ldelem_I1);
        case MetadataType.UInt16:
          return Instruction.Create(OpCodes.Ldelem_U2);
        case MetadataType.Int16:
          return Instruction.Create(OpCodes.Ldelem_I2);
        case MetadataType.UInt32:
          return Instruction.Create(OpCodes.Ldelem_U4);
        case MetadataType.Int32:
          return Instruction.Create(OpCodes.Ldelem_I4);
        case MetadataType.UInt64:
          return Instruction.Create(OpCodes.Ldelem_I8);
        case MetadataType.Int64:
          return Instruction.Create(OpCodes.Ldelem_I8);
        case MetadataType.Single:
          return Instruction.Create(OpCodes.Ldelem_R4);
        case MetadataType.Double:
          return Instruction.Create(OpCodes.Ldelem_R8);

        default:
          if (type.IsValueType) {
            return Instruction.Create(OpCodes.Ldelem_Any, type);
          } else {
            return Instruction.Create(OpCodes.Ldelem_Ref);
          }
      }
    }

    public static Instruction Stelem(TypeReference type) {
      switch (type.MetadataType) {
        case MetadataType.Byte:
        case MetadataType.SByte:
          return Instruction.Create(OpCodes.Stelem_I1);
        case MetadataType.UInt16:
        case MetadataType.Int16:
          return Instruction.Create(OpCodes.Stelem_I2);
        case MetadataType.UInt32:
        case MetadataType.Int32:
          return Instruction.Create(OpCodes.Stelem_I4);
        case MetadataType.UInt64:
        case MetadataType.Int64:
          return Instruction.Create(OpCodes.Stelem_I8);
        case MetadataType.Single:
          return Instruction.Create(OpCodes.Stelem_R4);
        case MetadataType.Double:
          return Instruction.Create(OpCodes.Stelem_R8);
        default:
          if (type.IsValueType) {
            return Instruction.Create(OpCodes.Stelem_Any, type);
          } else {
            return Instruction.Create(OpCodes.Stelem_Ref);
          }
      }
    }

    public static Instruction Ldelema(TypeReference arg) => Instruction.Create(OpCodes.Ldelema, arg);

    // conversions
    public static Instruction Conv_I4() => Instruction.Create(OpCodes.Conv_I4);
    public static Instruction Conv_U() => Instruction.Create(OpCodes.Conv_U);

    // functions
    public static Instruction Call(MethodReference  method) => Instruction.Create(OpCodes.Call,  method);
    public static Instruction Ldftn(MethodReference method) => Instruction.Create(OpCodes.Ldftn, method);

    // constants

    public static Instruction Ldstr(string value) => Instruction.Create(OpCodes.Ldstr, value);
    public static Instruction Ldc_R4(float value) => Instruction.Create(OpCodes.Ldc_R4, value);
    public static Instruction Ldc_R8(float value) => Instruction.Create(OpCodes.Ldc_R8, value);

    public static Instruction Ldc_I4(int value) {
      switch (value) {
        case 0: return Instruction.Create(OpCodes.Ldc_I4_0);
        case 1: return Instruction.Create(OpCodes.Ldc_I4_1);
        case 2: return Instruction.Create(OpCodes.Ldc_I4_2);
        case 3: return Instruction.Create(OpCodes.Ldc_I4_3);
        case 4: return Instruction.Create(OpCodes.Ldc_I4_4);
        case 5: return Instruction.Create(OpCodes.Ldc_I4_5);
        case 6: return Instruction.Create(OpCodes.Ldc_I4_6);
        case 7: return Instruction.Create(OpCodes.Ldc_I4_7);
        case 8: return Instruction.Create(OpCodes.Ldc_I4_8);
        default:
          return Instruction.Create(OpCodes.Ldc_I4, value);
      }
    }

    public static Instruction Stind_I4() => Instruction.Create(OpCodes.Stind_I4);
    public static Instruction Ldind_I4() => Instruction.Create(OpCodes.Ldind_I4);

    public static Instruction Stind_or_Stobj(TypeReference type) {
      if (type.IsPrimitive) {
        return Stind(type);
      } else {
        return Stobj(type);
      }
    }

    public static Instruction Ldind_or_Ldobj(TypeReference type) {
      if (type.IsPrimitive) {
        return Ldind(type);
      } else {
        return Ldobj(type);
      }
    }

    public static Instruction Stind(TypeReference type) {
      switch (type.MetadataType) {
        case MetadataType.Byte:
        case MetadataType.SByte:
          return Instruction.Create(OpCodes.Stind_I1);
        case MetadataType.UInt16:
        case MetadataType.Int16:
          return Instruction.Create(OpCodes.Stind_I2);
        case MetadataType.UInt32:
        case MetadataType.Int32:
          return Instruction.Create(OpCodes.Stind_I4);
        case MetadataType.UInt64:
        case MetadataType.Int64:
          return Instruction.Create(OpCodes.Stind_I8);
        case MetadataType.Single:
          return Instruction.Create(OpCodes.Stind_R4);
        case MetadataType.Double:
          return Instruction.Create(OpCodes.Stind_R8);
        default:
          throw new ILWeaverException($"Unknown primitive type {type.FullName}");
      }
    }

    public static Instruction Ldind(TypeReference type) {
      switch (type.MetadataType) {
        case MetadataType.Byte:
          return Instruction.Create(OpCodes.Ldind_U1);
        case MetadataType.SByte:
          return Instruction.Create(OpCodes.Ldind_I1);
        case MetadataType.UInt16:
          return Instruction.Create(OpCodes.Ldind_U2);
        case MetadataType.Int16:
          return Instruction.Create(OpCodes.Ldind_I2);
        case MetadataType.UInt32:
          return Instruction.Create(OpCodes.Ldind_U4);
        case MetadataType.Int32:
          return Instruction.Create(OpCodes.Ldind_I4);
        case MetadataType.UInt64:
          return Instruction.Create(OpCodes.Ldind_I8);
        case MetadataType.Int64:
          return Instruction.Create(OpCodes.Ldind_I8);
        case MetadataType.Single:
          return Instruction.Create(OpCodes.Ldind_R4);
        case MetadataType.Double:
          return Instruction.Create(OpCodes.Ldind_R8);
        default:
          throw new ILWeaverException($"Unknown primitive type {type.FullName}");
      }
    }
  }
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverSettings.cs

#if FUSION_WEAVER
namespace Fusion.CodeGen {
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;

  static partial class ILWeaverSettings {

    public const string RuntimeAssemblyName = "Fusion.Runtime";

    internal static float GetNamedFloatAccuracy(string tag) {
      float? result = null;
      GetAccuracyPartial(tag, ref result);
      if ( result == null ) {
        throw new ArgumentOutOfRangeException($"Unknown accuracy tag: {tag}");
      }
      return result.Value;
    }

    internal static bool NullChecksForNetworkedProperties() {
      bool result = true;
      NullChecksForNetworkedPropertiesPartial(ref result);
      return result;
    }

    internal static bool IsAssemblyWeavable(string name) {
      bool result = false;
      IsAssemblyWeavablePartial(name, ref result);
      return result;
    }

    internal static bool ContainsRequiredReferences(string[] references) {
      return Array.Find(references, x => x.Contains(RuntimeAssemblyName)) != null;
    }

    internal static bool UseSerializableDictionaryForNetworkDictionaryProperties() {
      bool result = true;
      UseSerializableDictionaryForNetworkDictionaryPropertiesPartial(ref result);
      return result;
    }

    static partial void GetAccuracyPartial(string tag, ref float? accuracy);

    static partial void IsAssemblyWeavablePartial(string name, ref bool result);

    static partial void UseSerializableDictionaryForNetworkDictionaryPropertiesPartial(ref bool result);

    static partial void NullChecksForNetworkedPropertiesPartial(ref bool result);
  }
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverSettings.ILPostProcessor.cs

#if FUSION_WEAVER && FUSION_WEAVER_ILPOSTPROCESSOR
namespace Fusion.CodeGen {

  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using System.Runtime.Serialization.Json;
  using System.Text;
  using System.Xml.Linq;
  using System.Xml.XPath;

  static partial class ILWeaverSettings {


    public enum ConfigStatus {
      Ok,
      NotFound,
      ReadException
    }

    const string DefaultNetworkProjectConfigPath = "Assets/Photon/Fusion/Resources/NetworkProjectConfig.fusion";

    static partial void OverrideNetworkProjectConfigPath(ref string path);

    public static string NetworkProjectConfigPath {
      get {
        var result = DefaultNetworkProjectConfigPath;
        OverrideNetworkProjectConfigPath(ref result);
        return result;
      }
    }

    static Lazy<XDocument> _config = new Lazy<XDocument>(() => {
      using (var stream = File.OpenRead(NetworkProjectConfigPath)) {
        var jsonReader = JsonReaderWriterFactory.CreateJsonReader(stream, new System.Xml.XmlDictionaryReaderQuotas());
        return XDocument.Load(jsonReader);
      }
    });

    static Lazy<AccuracyDefaults> _accuracyDefaults = new Lazy<AccuracyDefaults>(() => {

      var element = GetElementOrThrow(_config.Value.Root, nameof(NetworkProjectConfig.AccuracyDefaults));

      AccuracyDefaults defaults = new AccuracyDefaults();

      {
        var t = ParseAccuracies(element, nameof(AccuracyDefaults.coreKeys), nameof(AccuracyDefaults.coreVals));
        defaults.coreKeys = t.Item1;
        defaults.coreVals = t.Item2;
      }

      {
        var t = ParseAccuracies(element, nameof(AccuracyDefaults.tags), nameof(AccuracyDefaults.values));
        defaults.tags = t.Item1.ToList();
        defaults.values = t.Item2.ToList();
      }

      defaults.RebuildLookup();
      return defaults;
    });

    static partial void GetAccuracyPartial(string tag, ref float? accuracy) {
      try {
        if (_accuracyDefaults.Value.TryGetAccuracy(tag, out var result)) {
          accuracy = result._value;
        }
      } catch (Exception ex) {
        throw new Exception("Error getting accuracy " + tag, ex);
      }
    }

    static partial void NullChecksForNetworkedPropertiesPartial(ref bool result) {
      result = _nullChecksForNetworkedProperties.Value ?? result;
    }

    static partial void IsAssemblyWeavablePartial(string name, ref bool result) {
      result = _assembliesToWeave.Value.Contains(name);
    }

    static partial void UseSerializableDictionaryForNetworkDictionaryPropertiesPartial(ref bool result) {
      result = _useSerializableDictionary.Value ?? result;
    }

    public static bool ValidateConfig(out ConfigStatus errorType, out Exception error) {
      try {
        error = null;
        if (!File.Exists(NetworkProjectConfigPath)) {
          errorType = ConfigStatus.NotFound;
          return false;
        }

        _ = _config.Value;
        _ = _assembliesToWeave.Value;

        errorType = ConfigStatus.Ok;
        return true;
      } catch (Exception ex) {
        error = ex;
        errorType = ConfigStatus.ReadException;
        return false;
      }
    }

    static XElement GetElementOrThrow(XElement element, string name) {
      var child = element.Element(name);
      if (child == null) {
        throw new InvalidOperationException($"Node {name} not found in config. (path: {element.GetXPath()})");
      }
      return child;
    }

    static IEnumerable<XElement> GetElementsOrThrow(XElement element, string name) {
      return GetElementOrThrow(element, name).Elements();
    }

    static float GetElementAsFloat(XElement element, string name) {
      var child = GetElementOrThrow(element, name);
      try {
        return (float)child;
      } catch (Exception ex) {
        throw new InvalidOperationException($"Unable to cast {child.GetXPath()} to float", ex);
      }
    }

    static (string[], Accuracy[]) ParseAccuracies(XElement element, string keyName, string valueName) {
      var keys = GetElementsOrThrow(element, keyName).Select(x => x.Value).ToArray();
      var values = GetElementsOrThrow(element, valueName).Select(x => GetElementAsFloat(x, nameof(Accuracy._value)))
                      .Zip(keys, (val, key) => new Accuracy(key, val))
                      .ToArray();
      return (keys, values);
    }

    static Lazy<HashSet<string>> _assembliesToWeave = new Lazy<HashSet<string>>(() => {
      return new HashSet<string>(GetElementsOrThrow(_config.Value.Root, nameof(NetworkProjectConfig.AssembliesToWeave)).Select(x => x.Value), StringComparer.OrdinalIgnoreCase);
    });

    static Lazy<bool?> _nullChecksForNetworkedProperties = new Lazy<bool?>(() => {
      return (bool?)_config.Value.Root.Element(nameof(NetworkProjectConfig.NullChecksForNetworkedProperties));
    });

    static Lazy<bool?> _useSerializableDictionary = new Lazy<bool?>(() => {
      return (bool?)_config.Value.Root.Element(nameof(NetworkProjectConfig.UseSerializableDictionary));
    });


    public static string GetXPath(this XElement element) {
      var ancestors = element.AncestorsAndSelf()
        .Select(x => {
          int index = x.GetIndexPosition();
          string name = x.Name.LocalName;
          return (index == -1) ? $"/{name}" : $"/{name}[{index}]";
        });

      return string.Concat(ancestors.Reverse());
    }

    public static int GetIndexPosition(this XElement element) {
      if (element.Parent == null) {
        return -1;
      }

      int i = 0;
      foreach (var sibling in element.Parent.Elements(element.Name)) {
        if (sibling == element) {
          return i;
        }
        i++;
      }

      return -1;
    }
  }
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/ILWeaverSettings.UnityEditor.cs

#if FUSION_WEAVER && !FUSION_WEAVER_ILPOSTPROCESSOR
namespace Fusion.CodeGen {

  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Linq;

  static partial class ILWeaverSettings {

    static partial void GetAccuracyPartial(string tag, ref float? accuracy) {
      if (NetworkProjectConfig.Global.AccuracyDefaults.TryGetAccuracy(tag, out var _acc)) {
        accuracy = _acc.Value;
      }
    }

    static partial void IsAssemblyWeavablePartial(string name, ref bool result) {
      if (Array.Find(NetworkProjectConfig.Global.AssembliesToWeave, x => string.Compare(name, x, true) == 0) != null) {
        result = true;
      }
    }

    static partial void UseSerializableDictionaryForNetworkDictionaryPropertiesPartial(ref bool result) {
      result = NetworkProjectConfig.Global.UseSerializableDictionary;
    }

    static partial void NullChecksForNetworkedPropertiesPartial(ref bool result) {
      result = NetworkProjectConfig.Global.NullChecksForNetworkedProperties;
    }
  }
}
#endif

#endregion


#region Assets/Photon/FusionCodeGen/InstructionEqualityComparer.cs

#if FUSION_WEAVER && FUSION_HAS_MONO_CECIL
namespace Fusion.CodeGen {
  using System.Collections.Generic;
  using Mono.Cecil.Cil;

  internal class InstructionEqualityComparer : IEqualityComparer<Instruction> {
    public bool Equals(Instruction x, Instruction y) {
      if (x.OpCode != y.OpCode) {
        return false;
      }

      if (x.Operand != y.Operand) {
        if (x.Operand?.GetType() != y?.Operand.GetType()) {
          return false;
        }
        // there needs to be a better way to do this
        if (x.Operand.ToString() != y.Operand.ToString()) {
          return false;
        }

      }

      return true;
    }

    public int GetHashCode(Instruction obj) {
      return obj.GetHashCode();
    }
  }
}
#endif

#endregion

#endif