VRCSDK3Avatars found!

14 files changed, 4315 insertions, 0 deletions

diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3EOSCConfiguration.cs b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3EOSCConfiguration.cs
new file mode 100644
index 00000000..e278b06c
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3EOSCConfiguration.cs
@@ -0,0 +1,219 @@
+using System;
+using UnityEngine;
+using VRC.SDK3.Avatars.Components;
+using VRC.SDK3.Avatars.ScriptableObjects;
+
+[Serializable]
+public struct A3EOSCConfiguration {
+    public bool UseRealPipelineIdJSONFile;
+    public bool SendRecvAllParamsNotInJSON;
+    public bool GenerateOSCConfig;
+    public bool LoadOSCConfig;
+    public bool SaveOSCConfig;
+    public string OSCAvatarID;
+    public string OSCFilePath;
+    public OuterJson OSCJsonConfig;
+
+    static bool whichtest;
+    [Serializable]
+    public struct InputOutputPath {
+        public string address;
+        public string type;
+    }
+    [Serializable]
+    public struct InnerJson {
+        public string name;
+        public InputOutputPath input;
+        public InputOutputPath output;
+    }
+    [Serializable]
+    public class OuterJson {
+        public string id;
+        public string name;
+        public InnerJson[] parameters;
+    }
+    readonly static string [][] OSC_BUILTIN_PARAMETERS = {
+        new string[]{"VelocityZ","Float"},
+        new string[]{"VelocityY","Float"},
+        new string[]{"VelocityX","Float"},
+        new string[]{"InStation","Bool"},
+        new string[]{"Seated","Bool"},
+        new string[]{"AFK","Bool"},
+        new string[]{"Upright","Float"},
+        new string[]{"AngularY","Float"},
+        new string[]{"Grounded","Bool"},
+        new string[]{"MuteSelf","Bool"},
+        new string[]{"VRMode","Int"},
+        new string[]{"TrackingType","Int"},
+        new string[]{"GestureRightWeight","Float"},
+        new string[]{"GestureRight","Int"},
+        new string[]{"GestureLeftWeight","Float"},
+        new string[]{"GestureLeft","Int"},
+        new string[]{"Voice","Float"},
+        new string[]{"Viseme","Int"}
+    };
+    public static OuterJson GenerateOuterJSON(VRC.SDK3.Avatars.ScriptableObjects.VRCExpressionParameters expparams, string id, string name) {
+        OuterJson oj = new OuterJson();
+        oj.id = id;
+        oj.name = name;
+        const string ADDRESS_PREFIX = "/avatar/parameters/";
+        int nonempty;
+        if (expparams == null) {
+            expparams = ScriptableObject.CreateInstance<VRCExpressionParameters>();
+            expparams.parameters = new VRCExpressionParameters.Parameter[] {
+                    new VRCExpressionParameters.Parameter {
+                        defaultValue = 0,
+                        saved = false,
+                        name = "VRCEmote",
+                        valueType = VRCExpressionParameters.ValueType.Int
+                    },
+                    new VRCExpressionParameters.Parameter {
+                        defaultValue = 0,
+                        saved = false,
+                        name = "VRCFaceBlendH",
+                        valueType = VRCExpressionParameters.ValueType.Float
+                    },
+                    new VRCExpressionParameters.Parameter {
+                        defaultValue = 0,
+                        saved = false,
+                        name = "VRCFaceBlendV",
+                        valueType = VRCExpressionParameters.ValueType.Float
+                    }
+            };
+        }
+        nonempty = expparams.parameters.Length;
+        foreach (var p in expparams.parameters) {
+            if (p.name.Length == 0) {
+                nonempty--;
+            }
+        }
+        oj.parameters = new InnerJson[OSC_BUILTIN_PARAMETERS.Length + nonempty];
+        int idx = 0;
+        // VRC writes these in reverse order. No idea why.
+        foreach (var p in expparams.parameters) {
+            if (p.name.Length != 0) {
+                oj.parameters[nonempty - idx - 1] = new InnerJson {
+                    name = p.name,
+                    input = new InputOutputPath {
+                        address = ADDRESS_PREFIX + p.name,
+                        type = (p.valueType == VRCExpressionParameters.ValueType.Int ? "Int" :
+                            (p.valueType == VRCExpressionParameters.ValueType.Float ? "Float" : "Bool"))
+                    },
+                    output = new InputOutputPath {
+                        address = ADDRESS_PREFIX + p.name,
+                        type = (p.valueType == VRCExpressionParameters.ValueType.Int ? "Int" :
+                            (p.valueType == VRCExpressionParameters.ValueType.Float ? "Float" : "Bool"))
+                    }
+                };
+                idx++;
+            }
+        }
+        for (int i = 0; i < OSC_BUILTIN_PARAMETERS.Length; i++) {
+            var bname = OSC_BUILTIN_PARAMETERS[i][0];
+            var btype = OSC_BUILTIN_PARAMETERS[i][1];
+            oj.parameters[idx] = new InnerJson {
+                name = bname,
+                output = new InputOutputPath {
+                    address = ADDRESS_PREFIX + bname,
+                    type = btype
+                }
+            };
+            idx++;
+        }
+        return oj;
+    }
+    public static OuterJson ReadJSON(string full_file_path) {
+        return JsonUtility.FromJson<OuterJson>(System.IO.File.ReadAllText(full_file_path));
+    }
+    public static void WriteJSON(string filename, OuterJson oj) {
+        // pretty print, remove empty {"input":{"address":"","type":""}} junk that unity dumps in, and match VRChat's whitespace.
+        System.IO.File.WriteAllLines(filename, System.Text.RegularExpressions.Regex.Replace("\ufeff" + 
+            System.Text.RegularExpressions.Regex.Replace(
+                JsonUtility.ToJson(oj, true), ",\\s*\"input\"\\s*:\\s*{\\s*\"address\"\\s*:\\s*\"\"\\s*,\\s*\"type\"\\s*:\\s*\"\"\\s*}\\s*",""),
+                "\n(\\s*)\\1(\\S)", "\n$1$2").Split('\n'));
+    }
+
+    public const string AVTR_EMULATOR_PREFIX = "avtr_LyumaAv3Emulator_";
+    public void EnsureOSCJSONConfig(VRC.SDK3.Avatars.ScriptableObjects.VRCExpressionParameters expparams, string avatarid, string name) {
+        try {
+            string localLowPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            if (localLowPath.EndsWith("Local")) {
+                localLowPath = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(localLowPath), "LocalLow");
+            }
+            string userid = null;
+            string vrcOSCPath = System.IO.Path.Combine(localLowPath, "VRChat", "vrchat", "OSC");
+
+            System.Type apiusertype = System.Type.GetType("VRC.Core.APIUser, VRCCore-Editor");
+            if (apiusertype != null) {
+                var idprop = apiusertype.GetProperty("id", System.Reflection.BindingFlags.Instance|System.Reflection.BindingFlags.Public);
+                var prop = apiusertype.GetProperty("CurrentUser", System.Reflection.BindingFlags.Static|System.Reflection.BindingFlags.Public);
+                // Debug.Log("idprop " + idprop);
+                if (idprop != null && prop != null) {
+                    var apiuserinst = prop.GetValue(null);
+                    if (apiuserinst != null) {
+                        // Debug.Log("apiuser " + apiuserinst);
+                        userid = (string)idprop.GetValue(apiuserinst);
+                    }
+                }
+            }
+            try {
+                System.IO.Directory.CreateDirectory(vrcOSCPath);
+            } catch (System.IO.IOException) {
+            }
+            if (userid == null || userid.Length == 0) {
+                // do not have a known user account.
+                // find the most recent user folder.
+                DateTime dt = DateTime.MinValue;
+                // Debug.Log("lets-a look at " + vrcOSCPath);
+                foreach (string file in System.IO.Directory.GetDirectories(vrcOSCPath, "*", System.IO.SearchOption.TopDirectoryOnly)) {
+                    // Debug.Log("enumerate a file " + file);
+                    DateTime thisdt = System.IO.File.GetLastWriteTime(file);
+                    if (thisdt > dt) {
+                        userid = System.IO.Path.GetFileName(file);
+                        dt = thisdt;
+                    }
+                }
+            }
+            if (userid == null || userid.Length == 0) {
+                OSCAvatarID = "not_logged_in";
+                OSCFilePath = "No User folder was found. Please play VRC or login.";
+                OSCJsonConfig = GenerateOuterJSON(expparams, "not_logged_in", name);
+                return;
+            }
+            string avatarDirectory = System.IO.Path.Combine(vrcOSCPath, userid, "Avatars");
+            try {
+                System.IO.Directory.CreateDirectory(avatarDirectory);
+            } catch (System.IO.IOException) {
+            }
+            if (avatarid != null && UseRealPipelineIdJSONFile) {
+                OSCAvatarID = avatarid; // json file already exists: let's use it.
+                OSCFilePath = System.IO.Path.Combine(avatarDirectory, avatarid + ".json");
+            } else {
+                avatarid = AVTR_EMULATOR_PREFIX + (whichtest ? "A" : "B");
+                OSCFilePath = System.IO.Path.Combine(avatarDirectory, avatarid + ".json");
+                whichtest = !whichtest;
+                OSCAvatarID = avatarid;
+                WriteJSON(OSCFilePath, GenerateOuterJSON(expparams, avatarid, name));
+            }
+            if (System.IO.File.Exists(OSCFilePath)) {
+                try {
+                    OSCJsonConfig = ReadJSON(OSCFilePath);
+                } catch (Exception e) {
+                    Debug.LogException(e);
+                    Debug.Log("File failed to load. Generating new JSON for " + OSCAvatarID);
+                    OSCJsonConfig = GenerateOuterJSON(expparams, OSCAvatarID, name);
+                }
+            } else {
+                Debug.Log("File does not exist. Generating new JSON for " + OSCAvatarID);
+                OSCJsonConfig = GenerateOuterJSON(expparams, OSCAvatarID, name);
+            }
+        } catch (Exception e) {
+            Debug.LogException(e);
+            OSCAvatarID = "exception_generating_json";
+            OSCFilePath = e.Message;
+            Debug.Log("Unable to determine Avatar ID or JSON file path. Generating config.");
+            OSCJsonConfig = GenerateOuterJSON(expparams, "exception_generating_json", name);
+        }
+    }
+
+}
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3EOSCConfiguration.cs.meta b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3EOSCConfiguration.cs.meta
new file mode 100644
index 00000000..2e6245cb
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3EOSCConfiguration.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0a616815e5eee504280da16619284024
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3ESimpleOSC.cs b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3ESimpleOSC.cs
new file mode 100644
index 00000000..6b6d8d54
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3ESimpleOSC.cs
@@ -0,0 +1,682 @@
+/* A3ESimpleOSC for C#, version 0.1
+Copyright (c) 2022 Lyuma <xn.lyuma@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. */
+
+#if UNITY_5_3_OR_NEWER
+#define UNITY
+#endif
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+public class A3ESimpleOSC
+{
+    public enum Impulse {IMPULSE}
+    public struct TimeTag {
+        public int secs;
+        public int nsecs;
+        public override string ToString() {
+            return "" + secs + ":" + nsecs;
+        }
+    #if UNITY
+        public static implicit operator UnityEngine.Vector2Int(TimeTag tt) {
+            return new UnityEngine.Vector2Int { x = tt.secs, y = tt.nsecs };
+        }
+        public static implicit operator TimeTag(UnityEngine.Vector2Int v2) {
+            return new TimeTag { secs = v2.x, nsecs = v2.y };
+        }
+    #endif
+    }
+    public struct OSCColor {
+        public byte r;
+        public byte g;
+        public byte b;
+        public byte a;
+        public override string ToString() {
+            return "OSCColor<" + r + "," + g + "," + b + "," + a + ">";
+        }
+    #if UNITY
+        public static implicit operator UnityEngine.Color(OSCColor c) {
+            return (UnityEngine.Color)new UnityEngine.Color32 { r = c.r, g = c.g, b = c.b, a = c.a };
+        }
+        public static implicit operator OSCColor(UnityEngine.Color c) {
+            UnityEngine.Color32 c32 = (UnityEngine.Color32)c;
+            return new OSCColor { r = c32.r, g = c32.g, b = c32.b, a = c32.a };
+        }
+        public static implicit operator OSCColor(UnityEngine.Color32 c) {
+            return new OSCColor { r = c.r, g = c.g, b = c.b, a = c.a };
+        }
+        public static implicit operator UnityEngine.Color32(OSCColor c) {
+            return new UnityEngine.Color32 { r = c.r, g = c.g, b = c.b, a = c.a };
+        }
+    #endif
+    }
+    public struct OSCMessage {
+        public IPEndPoint sender;
+        public uint bundleId; // 0 if not in a bundle; positive integer if part of a bundle.
+        public string path;
+        public TimeTag time;
+        public string typeTag;
+        public object[] arguments;
+        public override string ToString() {
+            System.Text.StringBuilder ret = new System.Text.StringBuilder();
+            ret.Append("<OSCMessage ");
+            DebugInto(ret);
+            ret.Append(">");
+            return ret.ToString();
+        }
+        public void DebugInto(System.Text.StringBuilder ret, bool dispIPTime=true) {
+            ret.Append(path);
+            if (dispIPTime && sender != null) {
+                ret.Append("; from ");
+                ret.Append(sender.ToString());
+            }
+            if (dispIPTime && (time.secs != 0 || time.nsecs != 0)) {
+                ret.Append(" @");
+                ret.Append(time);
+            }
+            if (dispIPTime) {
+                ret.Append("; type ");
+                ret.Append(typeTag);
+            }
+            ret.Append(":\n");
+            DebugObjectArrayInto(ret, "  ", arguments);
+        }
+    }
+
+    public static bool DebugLoggingEnabled = true; // Set to false to handle bad data without logspam.
+    static void CryWolf(string logMsg) {
+        if (DebugLoggingEnabled) {
+            #if UNITY
+                UnityEngine.Debug.LogWarning(logMsg);
+            #else
+                System.Console.WriteLine(logMsg);
+            #endif
+        }
+    }
+
+    public static void DebugObjectArrayInto(System.Text.StringBuilder sb, string indent, object[] args) {
+        int idx = 0;
+        foreach (var arg in args) {
+            sb.Append(indent);
+            sb.Append("[Arg");
+            sb.Append(idx);
+            sb.Append("] = ");
+            switch (arg) {
+                case null:
+                    sb.Append("null");
+                    break;
+                case object[] subArgs:
+                    sb.Append("[\n");
+                    DebugObjectArrayInto(sb, indent + "    ", subArgs);
+                    sb.Append(indent + "]");
+                    break;
+                case byte[] subBytes:
+                    sb.Append("new byte[] {");
+                    bool first = true;
+                    foreach (byte b in subBytes) {
+                        if (!first) {
+                            sb.Append(",");
+                        }
+                        first = false;
+                        sb.Append((int)b);
+                    }
+                    sb.Append("}");
+                    break;
+                case float f:
+                    sb.Append(f.ToString("F4"));
+                    break;
+                case int i:
+                    sb.Append(i.ToString());
+                    break;
+                case bool b:
+                    sb.Append(b.ToString());
+                    break;
+                default:
+                    sb.Append("(");
+                    sb.Append(arg.GetType().Name);
+                    sb.Append(")");
+                    sb.Append(arg);
+                    break;
+            }
+            sb.Append("\n");
+            idx++;
+        }
+    }
+
+
+    /// Parsing / decoding functions:
+    static object ParseType(char typeTag, byte[] data, ref int offset) {
+        switch(typeTag) {
+            case 'T':
+                return true;
+            case 'F':
+                return false;
+            case 'N':
+                return null;
+            case 'I':
+                return Impulse.IMPULSE;
+            case 'i':
+                int iret = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset));
+                offset += 4;
+                return iret;
+            case 'f':
+                byte[] tmp = new byte[4];
+                Array.Copy(data, offset, tmp, 0, 4);
+                if (BitConverter.IsLittleEndian) {
+                    Array.Reverse(tmp);
+                }
+                float fret = BitConverter.ToSingle(tmp, 0);
+                offset += 4;
+                return fret;
+            case 't':
+                int secs = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset));
+                int nanosecs = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset + 4));
+                offset += 8;
+                return new TimeTag { secs = secs, nsecs = nanosecs };
+            case 's':
+                int strend = offset;
+                while (data[strend] != 0) {
+                    strend++;
+                }
+                tmp = new byte[strend - offset];
+                Array.Copy(data, offset, tmp, 0, strend - offset);
+                offset = strend;
+                offset = (offset + 4) & ~3;
+                return System.Text.Encoding.UTF8.GetString(tmp);
+            case 'b':
+                int len = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset));
+                offset += 4;
+                tmp = new byte[len];
+                Array.Copy(data, offset, tmp, 0, len);
+                offset += len;
+                offset = (offset + 3) & ~3;
+                return tmp;
+            // Non-standard types:
+            case 'r':
+                byte r = data[offset++];
+                byte g = data[offset++];
+                byte b = data[offset++];
+                byte a = data[offset++];
+                return new OSCColor { r = r, g = g, b = b, a = a };
+            case 'h':
+                long lret = IPAddress.NetworkToHostOrder(BitConverter.ToInt64(data, offset));
+                offset += 8;
+                return lret;
+            case 'd':
+                byte[] dtmp = new byte[8];
+                Array.Copy(data, offset, dtmp, 0, 8);
+                if (BitConverter.IsLittleEndian) {
+                    Array.Reverse(dtmp);
+                }
+                double dret = BitConverter.ToDouble(dtmp, 0);
+                offset += 8;
+                return dret;
+            case 'c':
+                uint cret = (uint)IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset));
+                offset += 4;
+                return cret;
+            default:
+                CryWolf("Unknown type tag " + typeTag + " offset " + offset);
+                break;
+        }
+        return null;
+    }
+
+    static void SerializeTypeInto(byte[] data, ref int offset, object value, char typeTag) {
+    	// Debug.Log("Serialize " + value.GetType() + " " + (value) + " as " + typeTag);
+        byte[]tmp;
+        switch (typeTag) {
+            case 'T':
+            case 'F':
+            case 'N':
+            case 'I':
+                break;
+            case 'i':
+                Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)value)), 0, data, offset, 4);
+                offset += 4;
+                break;
+            case 'f':
+                tmp = BitConverter.GetBytes((float)value);
+                if (BitConverter.IsLittleEndian) {
+                    Array.Reverse(tmp);
+                }
+                Array.Copy(tmp, 0, data, offset, 4);
+                offset += 4;
+                break;
+            case 't':
+                TimeTag v2;
+                switch (value) {
+                #if UNITY
+                    case UnityEngine.Vector2Int i2:
+                        v2 = (TimeTag)i2;
+                        break;
+                #endif
+                    default:
+                        v2 = (TimeTag)value;
+                        break;
+                }
+                Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)v2.secs)), 0, data, offset, 4);
+                Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)v2.nsecs)), 0, data, offset + 4, 4);
+                offset += 8;
+                break;
+            case 's':
+                tmp = System.Text.Encoding.UTF8.GetBytes((string)value);
+                Array.Copy(tmp, 0, data, offset, tmp.Length);
+                data[tmp.Length + offset] = 0;
+                offset += tmp.Length;
+                for (int endOffset = (offset + 4) & ~3; offset < endOffset; offset++) {
+                    data[offset] = 0;
+                }
+                break;
+            case 'b':
+                tmp = (byte[])value;
+                Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)tmp.Length)), 0, data, offset, 4);
+                offset += 4;
+                Array.Copy(tmp, 0, data, offset, tmp.Length);
+                data[tmp.Length + offset] = 0;
+                offset += tmp.Length;
+                for (int endOffset = (offset + 3) & ~3; offset < endOffset; offset++) {
+                    data[offset] = 0;
+                }
+                break;
+            // Non-standard types:
+            case 'r':
+                OSCColor col;
+                switch (value) {
+            #if UNITY
+                    case UnityEngine.Color32 unic32:
+                        col = (OSCColor)unic32;
+                        break;
+                    case UnityEngine.Color unic:
+                        col = (OSCColor)unic;
+                        break;
+            #endif
+                    default:
+                        col = (OSCColor)value;
+                        break;
+                }
+                data[offset++] = col.r;
+                data[offset++] = col.g;
+                data[offset++] = col.b;
+                data[offset++] = col.a;
+                break;
+            case 'h':
+                Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((long)value)), 0, data, offset, 8);
+                offset += 8;
+                break;
+            case 'd':
+                tmp = BitConverter.GetBytes((double)value);
+                if (BitConverter.IsLittleEndian) {
+                    Array.Reverse(tmp);
+                }
+                Array.Copy(tmp, 0, data, offset, 8);
+                offset += 8;
+                break;
+            case 'c':
+                Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)(uint)value)), 0, data, offset, 4);
+                offset += 4;
+                break;
+            default:
+                CryWolf("Unexpected type tag to serialize " + typeTag + " offset " + offset);
+                break;
+        }
+    }
+
+    public static void DecodeOSCInto(ConcurrentQueue<OSCMessage> outQueue, byte[] data, int offset, int length, IPEndPoint senderIp=null, uint bundleId=0, TimeTag bundleTimetag=new TimeTag(), uint bundleIdNested=0) {
+        if (offset == 0 && length > 20 && data[offset] == '#' && data[offset + 1] == 'b' && data[offset + 2] == 'u' && data[offset + 3] == 'n' &&
+            data[offset + 4] == 'd' && data[offset + 5] == 'l' && data[offset + 6] == 'e' && data[offset + 7] == 0) {
+            int secs = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset + 8));
+            int nanosecs = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset + 12));
+            bundleTimetag = new TimeTag { secs = secs, nsecs = nanosecs };
+            offset += 16;
+            while (offset < length) {
+                int msglen = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, offset));
+                offset += 4;
+                DecodeOSCInto(outQueue, data, offset, msglen, senderIp, bundleId, bundleTimetag, bundleId);
+                offset += msglen;
+            }
+            return;
+        }
+        OSCMessage msg = new OSCMessage();
+        msg.time = bundleTimetag;
+        msg.sender = senderIp;
+        msg.bundleId = bundleIdNested;
+        int strlen = 0;
+        while (data[offset + strlen] != 0) {
+            strlen++;
+        }
+        msg.path = System.Text.Encoding.UTF8.GetString(data, offset, strlen);
+        offset += strlen;
+        offset = (offset + 4) & ~3;
+        while (data[offset] != ',') {
+            offset++;
+        }
+        int typetags = offset;
+        while (data[offset] != 0) {
+            offset++;
+        }
+        msg.typeTag = System.Text.Encoding.ASCII.GetString(data, typetags, offset - typetags);
+        offset = (offset + 4) & ~3;
+        //msg.arguments = new object[msg.typeTag.Length];
+        List<object> topLevelArguments = new List<object>();
+        List<List<object>> nested = new List<List<object>>();
+        nested.Add(topLevelArguments);
+        for (int i = 1; i < msg.typeTag.Length; i++) {
+            // Debug.Log("doing type tag " + msg.typeTag[i] + " offset: " + offset);
+            object obj;
+            switch (msg.typeTag[i]) {
+            case '[':
+                nested.Add(new List<object>());
+                break;
+            case ']':
+                if (nested.Count > 1) {
+                    obj = nested[nested.Count - 1].ToArray();
+                    nested.RemoveAt(nested.Count - 1);
+                    nested[nested.Count - 1].Add(obj);
+                }
+                break;
+            default:
+                obj = ParseType(msg.typeTag[i], data, ref offset);
+                nested[nested.Count - 1].Add(obj);
+                break;
+            }
+        }
+        if (nested.Count != 1) {
+            CryWolf("Invalid nested count (mismatched start and end array in OSC message): " + msg.typeTag);
+        }
+        msg.arguments = topLevelArguments.ToArray();
+        outQueue.Enqueue(msg);
+    }
+
+    static void GenerateOSCTypeTagInto(System.Text.StringBuilder typeTag, object[] packet) {
+        if (typeTag.Length == 0) {
+            typeTag.Append(',');
+        }
+        foreach (object po in packet) {
+            switch(po) {
+                case object[] subArray:
+                    typeTag.Append('[');
+                    GenerateOSCTypeTagInto(typeTag, subArray);
+                    typeTag.Append(']');
+                    break;
+                case float f:
+                    typeTag.Append('f');
+                    break;
+                case int i:
+                    typeTag.Append('i');
+                    break;
+            #if UNITY
+                case UnityEngine.Color32 ui32:
+                case UnityEngine.Color ui:
+            #endif
+                case OSCColor i:
+                    typeTag.Append('r');
+                    break;
+                case true:
+                    typeTag.Append('T');
+                    break;
+                case false:
+                    typeTag.Append('F');
+                    break;
+                case null:
+                    typeTag.Append('N');
+                    break;
+                case Impulse.IMPULSE:
+                    typeTag.Append('I');
+                    break;
+                case string s:
+                    typeTag.Append('s');
+                    break;
+                case byte[] b:
+                    typeTag.Append('b');
+                    break;
+            #if UNITY
+                case UnityEngine.Vector2Int i2:
+            #endif
+                case TimeTag tt:
+                    typeTag.Append('t');
+                    break;
+                case double d:
+                    typeTag.Append('d');
+                    break;
+                case long l:
+                    typeTag.Append('h');
+                    break;
+                case uint c: // represent OSC char as uint. confusing???
+                    typeTag.Append('c');
+                    break;
+                default:
+                    CryWolf("Invalid type " + po.GetType() + " at " + typeTag);
+                    break;
+            }
+        }
+    }
+
+    public static void EncodeOSCInto(byte[] data, ref int offset, OSCMessage msg, string type_tag_override="") {
+        if (msg.typeTag == null || msg.typeTag.Length == 0) {
+            System.Text.StringBuilder sb = new System.Text.StringBuilder();
+            GenerateOSCTypeTagInto(sb, msg.arguments);
+            msg.typeTag = sb.ToString();
+        }
+        byte[] tmp = System.Text.Encoding.UTF8.GetBytes((string)msg.path);
+        Array.Copy(tmp, 0, data, offset, tmp.Length);
+        data[tmp.Length + offset] = 0;
+        offset += tmp.Length;
+        for (int endOffset = (offset + 4) & ~3; offset < endOffset; offset++) {
+            data[offset] = 0;
+        }
+        tmp = System.Text.Encoding.UTF8.GetBytes((string)msg.typeTag);
+        Array.Copy(tmp, 0, data, offset, tmp.Length);
+        data[tmp.Length + offset] = 0;
+        offset += tmp.Length;
+        for (int endOffset = (offset + 4) & ~3; offset < endOffset; offset++) {
+            data[offset] = 0;
+        }
+        List<object[]> nested = new List<object[]>();
+        nested.Add(msg.arguments);
+        List<int> nestedIdx = new List<int>();
+        nestedIdx.Add(0);
+        foreach (char ch in msg.typeTag) {
+            switch (ch) {
+            case ',':
+                continue;
+            case '[':
+                object[] newArr = (object[])nested[nested.Count-1][nestedIdx[nestedIdx.Count-1]];
+                nested.Add(newArr);
+                nestedIdx[nestedIdx.Count-1] += 1;
+                nestedIdx.Add(0);
+                break;
+            case ']':
+                nested.RemoveAt(nested.Count-1);
+                nestedIdx.RemoveAt(nestedIdx.Count-1);
+                break;
+            default:
+                SerializeTypeInto(data, ref offset, nested[nested.Count-1][nestedIdx[nestedIdx.Count-1]], ch);
+                nestedIdx[nestedIdx.Count-1] += 1;
+                break;
+            }
+        }
+    }
+
+    public static void EncodeOSCBundleInto(byte[] data, ref int offset, List<OSCMessage> packets, TimeTag tt) {
+        Array.Copy(new byte[]{(byte)'#',(byte)'b',(byte)'u',(byte)'n',(byte)'d',(byte)'l',(byte)'e',0}, 0, data, offset, 8);
+        offset += 8;
+        Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)tt.secs)), 0, data, offset, 4);
+        Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)tt.nsecs)), 0, data, offset + 4, 4);
+        offset += 8;
+        foreach (var msg in packets) {
+            int startOffset = offset;
+            offset += 4;
+            EncodeOSCInto(data, ref offset, msg);
+            int endOffset = offset;
+            Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)(endOffset - startOffset - 4))), 0, data, startOffset, 4);
+        }
+    }
+
+    public class UDPThread {
+        UdpClient udpServer;
+        public bool shutdown;
+        public int udp_port;
+        public uint bundleCounter; // just so callers know if it came from a bundle.
+        public ConcurrentQueue<OSCMessage> receivedMessageQueue = new ConcurrentQueue<OSCMessage>();
+
+        public IPEndPoint Open(int udp_port) {
+            udpServer = new UdpClient(udp_port);
+            return (IPEndPoint)udpServer.Client.LocalEndPoint;
+        }
+        public IPEndPoint Open(IPEndPoint local_udp_endpoint) {
+            udpServer = new UdpClient(local_udp_endpoint);
+            return (IPEndPoint)udpServer.Client.LocalEndPoint;
+        }
+        public void Connect(IPEndPoint endPoint) {
+            udpServer.Connect(endPoint);
+        }
+
+        public void mythread(){
+            while (!shutdown) {
+                var incomingIP = new IPEndPoint(IPAddress.Any, 0);
+                try {
+                    var data = udpServer.Receive(ref incomingIP);
+                    try {
+                        if (bundleCounter == 0) {
+                            bundleCounter += 1;
+                        }
+                        DecodeOSCInto(receivedMessageQueue, data, 0, data.Length, incomingIP, bundleCounter);
+                        bundleCounter += 1;
+                    } catch (Exception e) {
+                        CryWolf(e.ToString());
+                    }
+                } catch (SocketException) {
+                    if (!shutdown) {
+                        continue; //throw;
+                    }
+                }
+            }
+        }
+        public void Close() {
+            shutdown = true;
+            if (udpServer != null) {
+                udpServer.Close();
+            }
+        }
+        public void SendBytes(byte[] buffer, int length, IPEndPoint endPoint) {
+            if (endPoint == null) {
+                udpServer.Send(buffer, length);
+            } else {
+                udpServer.Send(buffer, length, endPoint);
+            }
+        }
+    }
+
+    Thread runningThread;
+    UDPThread udpThreadState;
+    byte[]scratchSpace = new byte[8192];
+    IPEndPoint unconnectedEndpoint = null;
+
+    // Two methods for establishing send relationship:
+    // I. A connected UDP socket cannot receive messages from other hosts.
+    public void Connect(IPEndPoint endPoint) {
+        udpThreadState.Connect(endPoint);
+    }
+    // II. This can be called freely for every datagram and only affects data sent.
+    public void SetUnconnectedEndpoint(IPEndPoint endPoint) {
+        unconnectedEndpoint = endPoint;
+    }
+
+    // Two methods for creating a socket (with or without bound local ip/port)
+    // I. Open a socket only. Avoids creating a thread.
+    public IPEndPoint OpenSendOnlyClient(int udp_port=0) {
+        return OpenSendOnlyClient(new IPEndPoint(IPAddress.Any, udp_port));
+    }
+    public IPEndPoint OpenSendOnlyClient(IPEndPoint local_udp_endpoint) {
+        runningThread = null;
+        udpThreadState = new UDPThread();
+        return udpThreadState.Open(local_udp_endpoint);
+    }
+
+    // II. Open a socket, and creates a thread for receiving.
+    public IPEndPoint OpenClient(int udp_port=0) {
+        return OpenClient(new IPEndPoint(IPAddress.Any, udp_port));
+    }
+    public IPEndPoint OpenClient(IPEndPoint local_udp_endpoint) {
+        if (udpThreadState != null) {
+            StopClient();
+            udpThreadState = null;
+        }
+        udpThreadState = new UDPThread();
+        IPEndPoint localEndPoint = udpThreadState.Open(local_udp_endpoint);
+        runningThread = new Thread(new ThreadStart(udpThreadState.mythread));
+        runningThread.Start();
+        return localEndPoint;
+    }
+
+    // Call this to close the socket, and join the thread if any.
+    public void StopClient() {
+        if (udpThreadState != null && !udpThreadState.shutdown) {
+            udpThreadState.Close();
+            if (runningThread != null) {
+                runningThread.Join(5000);
+            }
+        }
+    }
+
+    // Read data waiting in the buffer.
+    public void GetIncomingOSC(List<OSCMessage> incomingMessages) {
+        OSCMessage msg;
+        if (udpThreadState != null && runningThread != null) {
+            while (udpThreadState.receivedMessageQueue.TryDequeue(out msg)) {
+                incomingMessages.Add(msg);
+            }
+        }
+    }
+
+    // Send a single OSCMessage, not bundled.
+    public void SendOSCPacket(OSCMessage msg, byte[] buffer=null) {
+        if (buffer == null) {
+            buffer = scratchSpace;
+        }
+        int encodedLength = 0;
+        EncodeOSCInto(buffer, ref encodedLength, msg);
+        udpThreadState.SendBytes(buffer, encodedLength, unconnectedEndpoint);
+    }
+
+    // Send a single OSCMessage as a bundle.
+    public void SendOSCBundle(List<OSCMessage> messages, TimeTag ts, byte[] buffer=null) {
+        if (messages.Count == 0) {
+            CryWolf("Attempt to send bundle with no messages!");
+        }
+        if (buffer == null) {
+            buffer = scratchSpace;
+        }
+        int encodedLength = 0;
+        EncodeOSCBundleInto(buffer, ref encodedLength, messages, ts);
+        udpThreadState.SendBytes(buffer, encodedLength, unconnectedEndpoint);
+    }
+    public void SendRaw(byte[] buffer, int encodedLength) {
+        udpThreadState.SendBytes(buffer, encodedLength, unconnectedEndpoint);
+    }
+
+    // udpServer.Send(new byte[] { 1 }, 1); // if data is received reply letting the client know that we got his data          
+}
\ No newline at end of file
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3ESimpleOSC.cs.meta b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3ESimpleOSC.cs.meta
new file mode 100644
index 00000000..05af50c7
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/A3ESimpleOSC.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 569586a013b244842a857866dc572531
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/GestureManagerAv3Menu.cs b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/GestureManagerAv3Menu.cs
new file mode 100644
index 00000000..b91de425
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/GestureManagerAv3Menu.cs
@@ -0,0 +1,51 @@
+/* Copyright (c) 2020-2022 Lyuma <xn.lyuma@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. */
+
+using System;
+using UnityEngine;
+using System.Collections.Generic;
+using VRC.SDK3.Avatars.ScriptableObjects;
+
+public class GestureManagerAv3Menu : LyumaAv3Menu
+{
+
+    // public LyumaAv3Runtime Runtime;
+    // public VRCExpressionsMenu RootMenu;
+    // public bool IsMenuOpen { get; private set; }
+    // private int? _activeControlIndex = null;
+    // private string _activeControlParameterName;
+    public bool compact = true;
+
+    private void Awake()
+    {
+        IsMenuOpen = true;
+
+        if (LyumaAv3Runtime.addRuntimeDelegate != null) {
+            LyumaAv3Runtime.addRuntimeDelegate(this);
+        }
+    }
+
+    // public void ToggleMenu()
+    // {
+
+    //     IsMenuOpen = !IsMenuOpen;
+    // }
+
+}
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/GestureManagerAv3Menu.cs.meta b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/GestureManagerAv3Menu.cs.meta
new file mode 100644
index 00000000..2e1b707f
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/GestureManagerAv3Menu.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4cc9dba3b86035b43b8baaca33369f11
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Emulator.cs b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Emulator.cs
new file mode 100644
index 00000000..bb7e9dc3
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Emulator.cs
@@ -0,0 +1,155 @@
+/* Copyright (c) 2020-2022 Lyuma <xn.lyuma@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. */
+using UnityEngine;
+using System.Collections.Generic;
+using VRC.SDK3.Avatars.Components;
+
+[RequireComponent(typeof(Animator))]
+public class LyumaAv3Emulator : MonoBehaviour
+{
+    static readonly ulong EMULATOR_VERSION = 0x2_09_08_00;
+
+    public bool DefaultToVR = false;
+    public bool DefaultTestInStation = false;
+    public LyumaAv3Runtime.TrackingTypeIndex DefaultTrackingType = LyumaAv3Runtime.TrackingTypeIndex.HeadHands;
+    public VRCAvatarDescriptor.AnimLayerType DefaultAnimatorToDebug = VRCAvatarDescriptor.AnimLayerType.Base;
+    public bool RestartEmulator;
+    private bool RestartingEmulator;
+    public bool CreateNonLocalClone;
+    public int CreateNonLocalCloneCount;
+    [Tooltip("Simulate behavior with sub-animator parameter drivers prior to the 2021.1.1 patch (19 Jan 2021)")]
+    public bool legacySubAnimatorParameterDriverMode;
+    public bool legacyMenuGUI = true;
+    private bool lastLegacyMenuGUI = true;
+    public bool DisableAvatarDynamicsIntegration;
+    public bool WorkaroundPlayModeScriptCompile = true;
+    public bool DisableMirrorClone;
+    public bool DisableShadowClone;
+    private bool lastHead;
+    public bool EnableHeadScaling;
+    public bool ViewMirrorReflection;
+    public bool ViewBothRealAndMirror;
+
+    static public LyumaAv3Emulator emulatorInstance;
+    static public RuntimeAnimatorController EmptyController;
+
+    public List<LyumaAv3Runtime> runtimes = new List<LyumaAv3Runtime>();
+
+    private void Awake()
+    {
+        Animator animator = gameObject.GetOrAddComponent<Animator>();
+        animator.enabled = false;
+        animator.runtimeAnimatorController = EmptyController;
+        emulatorInstance = this;
+        VRCAvatarDescriptor[] avatars = FindObjectsOfType<VRCAvatarDescriptor>();
+        Debug.Log(this.name + ": Setting up Av3Emulator on "+avatars.Length + " avatars.", this);
+        foreach (var avadesc in avatars)
+        {
+            if (avadesc.GetComponent<PipelineSaver>() != null) {
+                Debug.Log("Found PipelineSaver on " + avadesc.name + ". Disabling clones and mirror copy.", avadesc);
+                DisableMirrorClone = true;
+                DisableShadowClone = true;
+                CreateNonLocalClone = false;
+                EnableHeadScaling = false;
+            }
+            try {
+                // Creates the playable director, and initializes animator.
+                var oml = avadesc.gameObject.GetOrAddComponent<UnityEngine.AI.OffMeshLink>();
+                oml.startTransform = this.transform;
+                bool alreadyHadComponent = avadesc.gameObject.GetComponent<LyumaAv3Runtime>() != null;
+                var runtime = avadesc.gameObject.GetOrAddComponent<LyumaAv3Runtime>();
+                if (oml != null) {
+                    GameObject.DestroyImmediate(oml);
+                }
+                runtime.emulator = this;
+                runtime.VRMode = DefaultToVR;
+                runtime.TrackingType = DefaultTrackingType;
+                runtime.InStation = DefaultTestInStation;
+                runtime.DebugDuplicateAnimator = DefaultAnimatorToDebug;
+                runtime.EnableHeadScaling = EnableHeadScaling;
+                runtimes.Add(runtime);
+                if (!alreadyHadComponent && !DisableShadowClone) {
+                    runtime.CreateShadowClone();
+                }
+                if (!alreadyHadComponent && !DisableMirrorClone) {
+                    runtime.CreateMirrorClone();
+                }
+                runtime.DisableMirrorAndShadowClones = DisableShadowClone && DisableMirrorClone;
+            } catch (System.Exception e) {
+                Debug.LogException(e);
+            }
+        }
+        if (WorkaroundPlayModeScriptCompile) {
+            LyumaAv3Runtime.ApplyOnEnableWorkaroundDelegate();
+        }
+    }
+
+    private void OnDestroy() {
+        foreach (var runtime in runtimes) {
+            Destroy(runtime);
+        }
+        runtimes.Clear();
+        LyumaAv3Runtime.updateSceneLayersDelegate(~0);
+    }
+
+    private void Update() {
+        if (RestartingEmulator) {
+            RestartingEmulator = false;
+            Awake();
+        } else if (RestartEmulator) {
+            RestartEmulator = false;
+            OnDestroy();
+            RestartingEmulator = true;
+        }
+        if (ViewBothRealAndMirror) {
+            LyumaAv3Runtime.updateSceneLayersDelegate(~0);
+        } else if (ViewMirrorReflection && !ViewBothRealAndMirror) {
+            LyumaAv3Runtime.updateSceneLayersDelegate(~(1<<10));
+        } else if (!ViewMirrorReflection && !ViewBothRealAndMirror) {
+            LyumaAv3Runtime.updateSceneLayersDelegate(~(1<<18));
+        }
+        if (EnableHeadScaling != lastHead) {
+            lastHead = EnableHeadScaling;
+            foreach (var runtime in runtimes) {
+                runtime.EnableHeadScaling = EnableHeadScaling;
+            }
+        }
+        if (lastLegacyMenuGUI != legacyMenuGUI) {
+            lastLegacyMenuGUI = legacyMenuGUI;
+            foreach (var runtime in runtimes) {
+                runtime.legacyMenuGUI = legacyMenuGUI;
+            }
+        }
+        if (CreateNonLocalClone) {
+            CreateNonLocalCloneCount -= 1;
+            if (CreateNonLocalCloneCount <= 0) {
+                CreateNonLocalClone = false;
+            }
+            foreach (var runtime in runtimes)
+            {
+                if (runtime.AvatarSyncSource == runtime)
+                {
+                    runtime.CreateNonLocalClone = true;
+                }
+            }
+        }
+    }
+
+}
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Emulator.cs.meta b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Emulator.cs.meta
new file mode 100644
index 00000000..9b3a898b
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Emulator.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 226ca8e52c3922d4a85b20831b97caf3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Menu.cs b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Menu.cs
new file mode 100644
index 00000000..1fa5c89f
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Menu.cs
@@ -0,0 +1,235 @@
+/* Copyright (c) 2020-2022 Lyuma <xn.lyuma@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. */
+
+using System;
+using UnityEngine;
+using System.Collections.Generic;
+using VRC.SDK3.Avatars.ScriptableObjects;
+
+public class LyumaAv3Menu : MonoBehaviour
+{
+    public bool useLegacyMenu = true;
+    [Serializable]
+    public class MenuConditional
+    {
+        public VRCExpressionsMenu ExpressionsMenu { get; }
+        public LyumaAv3Runtime.FloatParam MandatedParam { get; }
+
+        public MenuConditional(VRCExpressionsMenu expressionsMenu)
+        {
+            ExpressionsMenu = expressionsMenu;
+        }
+
+        public MenuConditional(VRCExpressionsMenu expressionsMenu, LyumaAv3Runtime.FloatParam mandatedParam)
+        {
+            ExpressionsMenu = expressionsMenu;
+            MandatedParam = mandatedParam;
+        }
+
+        bool ShouldMenuRemainOpen(List<LyumaAv3Runtime.FloatParam> allConditions)
+        {
+            if (MandatedParam.name == null) return true;
+
+            var actualParam = allConditions.Find(param => param.name == MandatedParam.name);
+            if (actualParam == null) return false;
+            return actualParam.exportedValue == MandatedParam.exportedValue;
+        }
+    }
+
+    public LyumaAv3Runtime Runtime;
+    public VRCExpressionsMenu RootMenu;
+    public List<MenuConditional> MenuStack { get; } = new List<MenuConditional>();
+    public bool IsMenuOpen { get; protected set; }
+    private int? _activeControlIndex = null;
+    private string _activeControlParameterName;
+
+    private void Awake()
+    {
+        IsMenuOpen = true;
+
+        if (LyumaAv3Runtime.addRuntimeDelegate != null) {
+            LyumaAv3Runtime.addRuntimeDelegate(this);
+        }
+    }
+
+    public void ToggleMenu()
+    {
+        if (IsMenuOpen && _activeControlIndex != null)
+        {
+            UserControlExit();
+        }
+
+        IsMenuOpen = !IsMenuOpen;
+    }
+
+    public void UserToggle(string paramName, float wantedValue) {
+        var intx = Runtime.Ints.Find(param => param.name == paramName);
+        if (intx != null) {
+            var currentValue = intx.value;
+            var newValue = (int)wantedValue == currentValue ? 0 : wantedValue;
+            DoSetRuntimeX(paramName, newValue);
+        }
+        var floatx = Runtime.Floats.Find(param => param.name == paramName);
+        if (floatx != null) {
+            var currentValue = floatx.exportedValue;
+            var newValue = wantedValue == currentValue ? 0.0f : wantedValue;
+            DoSetRuntimeX(paramName, newValue);
+        }
+        var boolx = Runtime.Bools.Find(param => param.name == paramName);
+        if (boolx != null) {
+            var currentValue = boolx.value;
+            var newValue = !currentValue;
+            DoSetRuntimeX(paramName, newValue ? 1.0f : 0.0f);
+        }
+    }
+
+    public void UserSubMenu(VRCExpressionsMenu subMenu)
+    {
+        MenuStack.Add(new MenuConditional(subMenu));
+    }
+
+    public void UserSubMenu(VRCExpressionsMenu subMenu, string paramName, float wantedValue)
+    {
+        MenuStack.Add(new MenuConditional(subMenu, new LyumaAv3Runtime.FloatParam {name = paramName, value = wantedValue, exportedValue = wantedValue}));
+        DoSetRuntimeX(paramName, wantedValue);
+    }
+
+    public void UserBack()
+    {
+        if (MenuStack.Count == 0) return;
+        if (_activeControlIndex != null) return;
+
+        var lastIndex = MenuStack.Count - 1;
+
+        var last = MenuStack[lastIndex];
+        if (last.MandatedParam != null)
+        {
+            DoSetRuntimeX(last.MandatedParam.name, 0.0f);
+        }
+        MenuStack.RemoveAt(lastIndex);
+    }
+
+    public void UserControlEnter(int controlIndex)
+    {
+        if (_activeControlIndex != null) return;
+
+        _activeControlIndex = controlIndex;
+    }
+
+    public void UserControlEnter(int controlIndex, string paramName, float enterValue)
+    {
+        if (_activeControlIndex != null) return;
+
+        _activeControlIndex = controlIndex;
+        _activeControlParameterName = paramName;
+        DoSetRuntimeX(paramName, enterValue);
+    }
+
+    public void UserControlExit()
+    {
+        if (_activeControlIndex == null) return;
+
+        if (_activeControlParameterName != null)
+        {
+            DoSetRuntimeX(_activeControlParameterName, 0.0f);
+        }
+        _activeControlIndex = null;
+        _activeControlParameterName = null;
+    }
+
+    private void DoSetRuntimeX(string paramName, float newValue)
+    {
+        var intParam = Runtime.Ints.Find(param => param.name == paramName);
+        if (intParam != null) {
+            intParam.value = (int)newValue;
+        }
+        var floatParam = Runtime.Floats.Find(param => param.name == paramName);
+        if (floatParam != null) {
+            floatParam.value = newValue;
+            floatParam.exportedValue = newValue;
+        }
+        var boolParam = Runtime.Bools.Find(param => param.name == paramName);
+        if (boolParam != null) {
+            boolParam.value = newValue != 0.0;
+        }
+    }
+
+    public bool IsVisualActive(string paramName, float value)
+    {
+        var intParam = Runtime.Ints.Find(param => param.name == paramName);
+        if (intParam != null) {
+            return intParam.value == (int)value;
+        }
+
+        var floatParam = Runtime.Floats.Find(param => param.name == paramName);
+        if (floatParam != null) {
+            return floatParam.exportedValue == value;
+        }
+
+        var boolParam = Runtime.Bools.Find(param => param.name == paramName);
+        if (boolParam != null) {
+            return boolParam.value == (value != 0.0);
+        }
+        return false;
+    }
+
+    public float FindFloat(string paramName)
+    {
+        var floatParam = Runtime.Floats.Find(param => param.name == paramName);
+        if (floatParam == null) return 0;
+
+        return floatParam.exportedValue;
+    }
+
+    public void UserFloat(string paramName, float newValue)
+    {
+        var floatParam = Runtime.Floats.Find(param => param.name == paramName);
+        if (floatParam == null) return;
+
+        floatParam.value = newValue;
+        floatParam.exportedValue = newValue;
+    }
+
+    public bool HasActiveControl()
+    {
+        return _activeControlIndex != null;
+    }
+
+    public bool IsActiveControl(int controlIndex)
+    {
+        return _activeControlIndex == controlIndex;
+    }
+    public bool IsControlIKSynced(string ParamName) {
+        if (_activeControlIndex == null || !_activeControlIndex.HasValue) {
+            return false;
+        }
+        int idx = _activeControlIndex.Value;
+        var lastStack = MenuStack.Count == 0 ? RootMenu : MenuStack[MenuStack.Count - 1].ExpressionsMenu;
+        if (lastStack != null && lastStack.controls != null && idx < lastStack.controls.Count) {
+            var control = lastStack.controls[idx];
+            foreach (var subp in control.subParameters) {
+                if (subp.name == ParamName) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Menu.cs.meta b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Menu.cs.meta
new file mode 100644
index 00000000..178833f5
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Menu.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3865e5f6001a4a9286e8c3f33314c306
+timeCreated: 1604151153
\ No newline at end of file
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Osc.cs b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Osc.cs
new file mode 100644
index 00000000..b2d679ae
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Osc.cs
@@ -0,0 +1,375 @@
+/* Copyright (c) 2020-2022 Lyuma <xn.lyuma@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. */
+using UnityEngine;
+using System.Collections.Generic;
+using System.Linq;
+
+public class LyumaAv3Osc : MonoBehaviour {
+    public delegate Rect GetEditorViewport();
+    public static GetEditorViewport GetEditorViewportDelegate;
+
+    public delegate void DrawDebugRect(Rect pos, Color col, Color outlineCol);
+    public static DrawDebugRect DrawDebugRectDelegate;
+    public delegate void DrawDebugText(Rect contentRect, Color backgroundCol, Color outlineCol, Color textCol, string str, TextAnchor alignment);
+    public static DrawDebugText DrawDebugTextDelegate;
+
+    private LyumaAv3Emulator emulator;
+    A3ESimpleOSC receiver;
+    [Header("OSC Connection")]
+    public bool openSocket = false;
+    public bool disableOSC = false;
+    public bool resendAllParameters = false;
+    byte[] oscBuffer = new byte[65535];
+    public int udpPort = 9000;
+    public string outgoingUdpIp = "127.0.0.1";
+    public int outgoingUdpPort = 9001;
+    [SerializeField] private string commandLine = "";
+    private int oldPort = 9000;
+    [Header("OSC Status")]
+    [SerializeField] private int localPort;
+    [SerializeField] private string localIp;
+    [SerializeField] private int numberOfOSCMessages;
+    [Header("Target Avatar")]
+    public VRC.SDK3.Avatars.Components.VRCAvatarDescriptor avatarDescriptor;
+    public bool forwardToAllAvatarsInScene;
+    
+    [Header("Gizmo settings")]
+    public bool alwaysShowOSCGizmos = true;
+    public bool clearGizmos = false;
+    public Color GizmoFilledColor = new Color(1.0f,0.0f,1.0f,0.1f);
+    public Color GizmoBackgroundColor = new Color(0.75f,0.0f,0.6f,0.05f);
+    public Color GizmoOutlineColor = new Color(0.9f,0.7f,0.8f,0.5f);
+    public Color GizmoTextColor = new Color(1.0f,0.8f,1.0f,0.9f); //new Color(0.2f,1.0f,0.5f,1.0f);
+    protected Color GizmoBoundsColor = new Color(0.0f,0.0f,0.0f,0.6f); //new Color(0.2f,1.0f,0.5f,1.0f);
+    public bool GizmoShowSenderIP;
+    [Header("Debug options")]
+    public bool sendLoopbackOSCReplies;
+    public bool debugPrintReceivedMessages;
+
+    
+
+    public Dictionary<string, A3ESimpleOSC.OSCMessage> knownPaths = new Dictionary<string, A3ESimpleOSC.OSCMessage>();
+    Dictionary<string, Vector2> minMaxByPath = new Dictionary<string, Vector2>();
+    private List<A3ESimpleOSC.OSCMessage> messages = new List<A3ESimpleOSC.OSCMessage>();
+    Dictionary<string, A3ESimpleOSC.OSCMessage> lastSent = new Dictionary<string, A3ESimpleOSC.OSCMessage>();
+
+    public void Start() {
+        LyumaAv3Emulator[] emulators = FindObjectsOfType<LyumaAv3Emulator>();
+        if (emulators == null || emulators.Length == 0) {
+            return;
+        }
+        emulator = emulators[0];
+        if (emulator != null && emulator.runtimes != null) {
+            if (emulator.runtimes.Count > 0) {
+                avatarDescriptor = emulator.runtimes[0].GetComponent<VRC.SDK3.Avatars.Components.VRCAvatarDescriptor>();
+            }
+        }
+    }
+    public void Update() {
+        LyumaAv3Runtime runtime = avatarDescriptor != null ?avatarDescriptor.GetComponent<LyumaAv3Runtime>() : null;
+        commandLine = "--osc=" + udpPort + ":" + outgoingUdpIp + ":" + outgoingUdpPort;
+        if (clearGizmos) {
+            clearGizmos = false;
+            knownPaths.Clear();
+            minMaxByPath.Clear();
+        }
+        if (openSocket && receiver != null && oldPort != udpPort) {
+            receiver.StopClient();
+            receiver = null;
+        }
+        if ((!disableOSC && openSocket) && receiver == null) {
+            localIp = "";
+            localPort = -1;
+            oldPort = udpPort;
+            receiver = new A3ESimpleOSC();
+            bool success = false;
+            try {
+                var localEndpoint = receiver.OpenClient(udpPort);
+                localIp = localEndpoint.Address.ToString();
+                localPort = localEndpoint.Port;
+                success = localEndpoint.Port == udpPort || (udpPort == 0 && localEndpoint.Port > 0);
+            } catch (System.Exception  e) {
+                localIp = e.Message;
+                Debug.LogException(e);
+            }
+            if (!success) {
+                Debug.LogError("Failed to bind socket to OSC");
+                openSocket = false;
+            } else {
+                resendAllParameters = true;
+            }
+        }
+        if ((disableOSC||!openSocket) && receiver != null) {
+            receiver.StopClient();
+            receiver = null;
+        }
+        if (resendAllParameters) {
+            resendAllParameters = false;
+            lastSent.Clear();
+        }
+        messages.Clear();
+        if (receiver != null) {
+            receiver.GetIncomingOSC(messages);
+            if (sendLoopbackOSCReplies && messages.Count > 0) {
+                receiver.SetUnconnectedEndpoint(messages[0].sender);
+                var tt = new A3ESimpleOSC.TimeTag();
+                for (int i = 0; i < messages.Count; i++) {
+                    if (messages[i].bundleId != 0) {
+                        tt = messages[i].time;
+                        break;
+                    }
+                }
+                receiver.SendOSCBundle(messages, tt);
+            }
+            foreach (var msg in messages) {
+                numberOfOSCMessages += 1;
+                if (debugPrintReceivedMessages) {
+                    Debug.Log("Got OSC message: " + msg.ToString());
+                }
+                knownPaths[msg.path] = msg;
+                if (!minMaxByPath.ContainsKey(msg.path)) {
+                    minMaxByPath[msg.path] = new Vector2(0,0);
+                }
+            }
+            if (forwardToAllAvatarsInScene) {
+                if (emulator != null && emulator.runtimes != null) {
+                    foreach (var instRuntime in emulator.runtimes) {
+                        instRuntime.HandleOSCMessages(messages);
+                    }
+                }
+            } else if (runtime != null) {
+                runtime.HandleOSCMessages(messages);
+            }
+        }
+        if (runtime != null && receiver != null) {
+            messages.Clear();
+            runtime.GetOSCDataInto(messages);
+            if (messages.Count > 0) {
+                receiver.SetUnconnectedEndpoint(new System.Net.IPEndPoint(System.Net.IPAddress.Parse(outgoingUdpIp), outgoingUdpPort));
+                // receiver.SendOSCBundle(messages, new A3ESimpleOSC.TimeTag { secs=-1, nsecs=-1 }, oscBuffer);
+                foreach (var message in messages) {
+                    if (lastSent.ContainsKey(message.path) && Enumerable.SequenceEqual(message.arguments, lastSent[message.path].arguments)) {
+                        continue;
+                    }
+                    lastSent[message.path] = message;
+                    if (debugPrintReceivedMessages) {
+                        Debug.Log("Sending " + message + " to " + outgoingUdpIp + ":" + outgoingUdpPort);
+                    }
+                    receiver.SendOSCPacket(message, oscBuffer);
+                }
+            }
+        }
+        if (!enabled && receiver != null) {
+            receiver = null;
+        }
+    }
+    public void OnDestroy() {
+        if (receiver != null) {
+            receiver.StopClient();
+        }
+    }
+    
+    Vector3 ScreenToWorld(float x, float y) {
+        Camera camera = Camera.current;
+        Vector3 s = camera.WorldToScreenPoint(transform.position);
+        return camera.ScreenToWorldPoint(new Vector3(x, camera.pixelHeight - y, s.z));
+    }
+
+    Rect ScreenRect(int x, int y, int w, int h) {
+        Vector3 tl = ScreenToWorld(x, y);
+        Vector3 br = ScreenToWorld(x + w, y + h);
+        return new Rect(tl.x, tl.y, br.x - tl.x, br.y - tl.y);
+    }
+    void OnDrawGizmos() {
+        if (alwaysShowOSCGizmos) {
+            ActuallyDrawGizmos();
+        }
+    }
+    void RenderBoxType(Rect r, Vector2 v2, Vector2 minMaxHoriz, Vector2 minMaxVert) {
+        float xrange = Mathf.Max(0.001f, minMaxHoriz.y - minMaxHoriz.x);
+        float yrange = Mathf.Max(0.001f, minMaxVert.y - minMaxVert.x);
+        Rect r2 = (Rect)r;
+        Rect r3 = (Rect)r;
+        float f = v2.x;
+        float g = v2.y;
+        float widOffset = r.width * Mathf.Clamp01((v2.x - minMaxHoriz.x) / xrange);
+        float heiOffset = r.height * Mathf.Clamp01(1.0f - (v2.y - minMaxVert.x) / yrange);
+        r.y += heiOffset;
+        r.height -= heiOffset;
+        DrawDebugRectDelegate(r, GizmoFilledColor, GizmoFilledColor);
+        r2.width = widOffset;
+        DrawDebugRectDelegate(r2, GizmoFilledColor, GizmoFilledColor);
+        DrawDebugTextDelegate(r3, new Color(0,0,0,0), new Color(0,0,0,0), GizmoBoundsColor, "\n\n\n\n"+minMaxHoriz.x.ToString("F2"), TextAnchor.MiddleLeft);
+        DrawDebugTextDelegate(r3, new Color(0,0,0,0), new Color(0,0,0,0), GizmoBoundsColor, minMaxHoriz.y.ToString("F2")+"\n\n\n\n", TextAnchor.MiddleRight);
+        DrawDebugTextDelegate(r3, new Color(0,0,0,0), new Color(0,0,0,0), GizmoBoundsColor, minMaxVert.x.ToString("F2")+"\n", TextAnchor.LowerCenter);
+        DrawDebugTextDelegate(r3, new Color(0,0,0,0), new Color(0,0,0,0), GizmoBoundsColor, "\n"+minMaxVert.y.ToString("F2"), TextAnchor.UpperCenter);
+    }
+    void RenderBoxType(Rect r, float f2, Vector2 minMax) {
+        float xrange = Mathf.Max(0.001f, minMax.y - minMax.x);
+        float widOffset = r.width * Mathf.Clamp01(1.0f - (f2 - minMax.x) / xrange);
+        Rect r3 = (Rect)r;
+        r.width -= widOffset;
+        DrawDebugRectDelegate(r, GizmoFilledColor, GizmoFilledColor);
+        DrawDebugTextDelegate(r3, new Color(0,0,0,0), new Color(0,0,0,0), GizmoBoundsColor, "\n\n\n\n"+minMax.x.ToString("F2"), TextAnchor.MiddleLeft);
+        DrawDebugTextDelegate(r3, new Color(0,0,0,0), new Color(0,0,0,0), GizmoBoundsColor, minMax.y.ToString("F2")+"\n\n\n\n", TextAnchor.MiddleRight);
+    }
+    void RenderBoxType(Rect r, int i2, Vector2Int minMax) {
+        float heiOffset = r.height * Mathf.Clamp01(1.0f - (i2 - minMax.x) / Mathf.Max(1.0f, minMax.y - minMax.x));
+        Rect r3 = (Rect)r;
+        r.y += heiOffset;
+        r.height -= heiOffset;
+        DrawDebugRectDelegate(r, GizmoFilledColor, GizmoFilledColor);
+        DrawDebugTextDelegate(r3, new Color(0,0,0,0), new Color(0,0,0,0), GizmoBoundsColor, minMax.x.ToString()+"\n", TextAnchor.LowerCenter);
+        DrawDebugTextDelegate(r3, new Color(0,0,0,0), new Color(0,0,0,0), GizmoBoundsColor, "\n"+minMax.y.ToString(), TextAnchor.UpperCenter);
+    }
+    void RenderBoxType(Rect r, bool b2) {
+        if (b2) {
+            DrawDebugRectDelegate(r, GizmoFilledColor, GizmoFilledColor);
+        }
+    }
+
+    
+    HashSet<string> usedPartners = new HashSet<string>();
+    Dictionary<string, string> replacePairs = new Dictionary<string, string> {
+        {"Vertical", "Horizontal"},
+        {"Z", "X"},
+        {"Y", "X"},
+        {"z", "x"},
+        {"y", "x"},
+    };
+    void OnDrawGizmosSelected() {
+        if (!alwaysShowOSCGizmos) {
+            ActuallyDrawGizmos();
+        }
+    }
+    void ActuallyDrawGizmos() {
+        Camera camera = Camera.current;
+        Matrix4x4 origMatrix = Gizmos.matrix;
+        Gizmos.matrix = camera.projectionMatrix * camera.transform.localToWorldMatrix;
+        Rect viewportSize = GetEditorViewportDelegate();
+        Rect pos = new Rect(5 + viewportSize.x,5 + viewportSize.y,190,190);
+        usedPartners.Clear();
+        // float maxy = 0;
+        int numBoxes = 0;
+        foreach (var pathPair in knownPaths) {
+            if (usedPartners.Contains(pathPair.Key)) {
+                // Already got output
+                continue;
+            }
+            A3ESimpleOSC.OSCMessage msg;
+            foreach (var replacePair in replacePairs) {
+                if (pathPair.Key.EndsWith(replacePair.Key)) {
+                    if (pathPair.Value.arguments.Length >= 1 && pathPair.Value.arguments[0].GetType() == typeof(float)) {
+                        string key = pathPair.Key.Substring(0, pathPair.Key.Length - replacePair.Key.Length) + replacePair.Value;
+                        if (knownPaths.TryGetValue(key, out msg) && msg.arguments.Length >= 1 && msg.arguments[0].GetType() == typeof(float)) {
+                            usedPartners.Add(key);
+                            break;
+                        }
+                    }
+                }
+            }
+            numBoxes++;
+            pos.x += pos.width + 10;
+            if (pos.x + pos.width > viewportSize.width) {
+                pos.x = 5 + viewportSize.x;
+                pos.y += pos.height + 10;
+            }
+        }
+        if (pos.y + pos.height > viewportSize.height) {
+            pos = new Rect(5 + viewportSize.x,5 + viewportSize.y,190,pos.height * viewportSize.height / (pos.y + pos.height + 100));
+        } else {
+            pos = new Rect(5 + viewportSize.x,5 + viewportSize.y,190,190);
+        }
+        foreach (var pathPair in knownPaths) {
+            bool isVec2 = false;
+            Vector2 vecVal = new Vector2();
+            if (usedPartners.Contains(pathPair.Key)) {
+                // Already got output
+                continue;
+            }
+            Vector2 minmaxVert = minMaxByPath[pathPair.Key];
+            Vector2 minmaxHoriz = new Vector2();
+            System.Text.StringBuilder str = new System.Text.StringBuilder();
+            foreach (var replacePair in replacePairs) {
+                if (pathPair.Key.EndsWith(replacePair.Key)) {
+                    if (pathPair.Value.arguments.Length >= 1 && pathPair.Value.arguments[0].GetType() == typeof(float)) {
+                        string key = pathPair.Key.Substring(0, pathPair.Key.Length - replacePair.Key.Length) + replacePair.Value;
+                        A3ESimpleOSC.OSCMessage msg;
+                        if (knownPaths.TryGetValue(key, out msg) && msg.arguments.Length >= 1 && msg.arguments[0].GetType() == typeof(float)) {
+                            msg.DebugInto(str, GizmoShowSenderIP);
+                            vecVal.y = (float)pathPair.Value.arguments[0];
+                            minmaxVert = new Vector2(Mathf.Min(minmaxVert.x, vecVal.y), Mathf.Max(minmaxVert.y, vecVal.y));
+                            minMaxByPath[pathPair.Key] = minmaxVert;
+
+                            vecVal.x = (float)msg.arguments[0];
+                            minmaxHoriz = minMaxByPath[key];
+                            minmaxHoriz = new Vector2(Mathf.Min(minmaxHoriz.x, vecVal.x), Mathf.Max(minmaxHoriz.y, vecVal.x));
+                            minMaxByPath[key] = minmaxHoriz;
+                            isVec2 = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            pathPair.Value.DebugInto(str, GizmoShowSenderIP);
+            Rect subPos = new Rect(pos);
+
+            Color bgc = (Color)(GizmoBackgroundColor);
+            if (isVec2) {
+                RenderBoxType(subPos, vecVal, minmaxHoriz, minmaxVert);
+            } else if (pathPair.Value.arguments != null && pathPair.Value.arguments.Length >= 1) {
+                A3ESimpleOSC.OSCMessage msg = pathPair.Value;
+                switch (msg.arguments[0]) {
+                    case float f:
+                        minmaxVert = new Vector2(Mathf.Min(minmaxVert.x, f), Mathf.Max(minmaxVert.y, f));
+                        minMaxByPath[pathPair.Key] = minmaxVert;
+                        RenderBoxType(subPos, f, minmaxVert);
+                        break;
+                    case int i:
+                        minmaxVert = new Vector2(Mathf.Min(minmaxVert.x, (float)i), Mathf.Max(minmaxVert.y, (float)i));
+                        minMaxByPath[pathPair.Key] = minmaxVert;
+                        if (i != 0) {
+                            DrawDebugRectDelegate(subPos, GizmoFilledColor, GizmoFilledColor);
+                        }
+                        RenderBoxType(subPos, i, new Vector2Int(0,255)); // Hardcode bounds. new Vector2Int((int)minmaxVert.x, (int)minmaxVert.y));
+                        break;
+                    case bool b:
+                        if (b) {
+                            DrawDebugRectDelegate(subPos, GizmoFilledColor, GizmoFilledColor);
+                        }
+                        RenderBoxType(subPos, b ? 1 : 0, new Vector2Int(0,1));
+                        // RenderBoxType(subPos, b);
+                        break;
+                }
+            }
+            // Color c0 = new Color(OUTLINE_COLOR);
+            DrawDebugRectDelegate(pos, bgc, GizmoOutlineColor);
+            DrawDebugTextDelegate(pos, new Color(0.0f,0.0f,1.0f,0.02f), GizmoOutlineColor, GizmoTextColor, str.ToString().Replace(";", "\n").Replace(" @", "\n@" )
+                .Replace("(Single)", "(Float)").Replace("/avatar/parameters/", ""), TextAnchor.MiddleCenter);
+            pos.x += pos.width + 10;
+            if (pos.x + pos.width > viewportSize.width) {
+                pos.x = 5 + viewportSize.x;
+                pos.y += pos.height + 10;
+            }
+            // pos = new Vector3(pos.x + 105, pos.y, pos.z);
+        }
+        Gizmos.matrix = origMatrix;
+    }
+}
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Osc.cs.meta b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Osc.cs.meta
new file mode 100644
index 00000000..b3b5946e
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Osc.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 784aa748a7308b94a8f15dcd76531956
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Runtime.cs b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Runtime.cs
new file mode 100644
index 00000000..04d73cc2
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Runtime.cs
@@ -0,0 +1,2529 @@
+/* Copyright (c) 2020-2022 Lyuma <xn.lyuma@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Animations;
+using UnityEngine.Playables;
+using VRC.SDK3.Avatars.Components;
+using VRC.SDK3.Avatars.ScriptableObjects;
+using VRC.SDK3.Dynamics.Contact.Components;
+using VRC.SDK3.Dynamics.PhysBone.Components;
+
+// [RequireComponent(typeof(Animator))]
+public class LyumaAv3Runtime : MonoBehaviour
+{
+    static public Dictionary<VRCAvatarDescriptor.AnimLayerType, RuntimeAnimatorController> animLayerToDefaultController = new Dictionary<VRCAvatarDescriptor.AnimLayerType, RuntimeAnimatorController>();
+    static public Dictionary<VRCAvatarDescriptor.AnimLayerType, AvatarMask> animLayerToDefaultAvaMask = new Dictionary<VRCAvatarDescriptor.AnimLayerType, AvatarMask>();
+    public delegate void UpdateSelectionFunc(UnityEngine.Object obj);
+    public static UpdateSelectionFunc updateSelectionDelegate;
+    public delegate void AddRuntime(Component runtime);
+    public static AddRuntime addRuntimeDelegate;
+    public delegate void UpdateSceneLayersFunc(int layers);
+    public static UpdateSceneLayersFunc updateSceneLayersDelegate;
+    public delegate void ApplyOnEnableWorkaroundDelegateType();
+    public static ApplyOnEnableWorkaroundDelegateType ApplyOnEnableWorkaroundDelegate;
+
+    public LyumaAv3Runtime OriginalSourceClone = null;
+
+    [Tooltip("Resets avatar state machine instantly")]
+    public bool ResetAvatar;
+    [Tooltip("Resets avatar state machine and waits until you uncheck this to start")]
+    public bool ResetAndHold;
+    [Tooltip("Click if you modified your menu or parameter list")]
+    public bool RefreshExpressionParams;
+    [Tooltip("Simulates saving and reloading the avatar")]
+    public bool KeepSavedParametersOnReset = true;
+    [HideInInspector] public bool legacyMenuGUI = true;
+    private bool lastLegacyMenuGUI = true;
+    [Header("Animator to Debug. Unity is glitchy when not 'Base'.")]
+    [Tooltip("Selects the playable layer to be visible with parameters in the Animator. If you view any other playable in the Animator window, parameters will say 0 and will not update.")]
+    public VRCAvatarDescriptor.AnimLayerType DebugDuplicateAnimator;
+    private char PrevAnimatorToDebug;
+    [Tooltip("Selects the playable layer to be visible in Unity's Animator window. Does not reset avatar. Unless this is set to Base, will cause 'Invalid Layer Index' logspam; layers will show wrong weight and parameters will all be 0.")]
+    public VRCAvatarDescriptor.AnimLayerType ViewAnimatorOnlyNoParams;
+    private char PrevAnimatorToViewLiteParamsShow0;
+    [HideInInspector] public string SourceObjectPath;
+    [HideInInspector] public LyumaAv3Runtime AvatarSyncSource;
+    private float nextUpdateTime = 0.0f;
+    [Header("OSC (double click OSC Controller for debug and port settings)")]
+    public bool EnableAvatarOSC = false;
+    public LyumaAv3Osc OSCController = null;
+    public A3EOSCConfiguration OSCConfigurationFile = new A3EOSCConfiguration();
+
+    [Header("Network Clones and Sync")]
+    public bool CreateNonLocalClone;
+    [Tooltip("In VRChat, 8-bit float quantization only happens remotely. Check this to test your robustness to quantization locally, too. (example: 0.5 -> 0.503")]
+    public bool locally8bitQuantizedFloats = false;
+    private int CloneCount;
+    [Range(0.0f, 2.0f)] public float NonLocalSyncInterval = 0.2f;
+    [Tooltip("Parameters visible in the radial menu will IK sync")] public bool IKSyncRadialMenu = true;
+    [Header("PlayerLocal and MirrorReflection")]
+    public bool EnableHeadScaling;
+    public bool DisableMirrorAndShadowClones;
+    [HideInInspector] public LyumaAv3Runtime MirrorClone;
+    [HideInInspector] public LyumaAv3Runtime ShadowClone;
+    [Tooltip("To view both copies at once")] public bool DebugOffsetMirrorClone = false;
+    public bool ViewMirrorReflection;
+    private bool LastViewMirrorReflection;
+    public bool ViewBothRealAndMirror;
+    private bool LastViewBothRealAndMirror;
+    [HideInInspector] public VRCAvatarDescriptor avadesc;
+    Avatar animatorAvatar;
+    Animator animator;
+    private RuntimeAnimatorController origAnimatorController;
+    public Dictionary<VRCAvatarDescriptor.AnimLayerType, RuntimeAnimatorController> allControllers = new Dictionary<VRCAvatarDescriptor.AnimLayerType, RuntimeAnimatorController>();
+
+    private Transform[] allTransforms;
+    private Transform[] allMirrorTransforms;
+    private Transform[] allShadowTransforms;
+    private List<AnimatorControllerPlayable> playables = new List<AnimatorControllerPlayable>();
+    private List<Dictionary<string, int>> playableParamterIds = new List<Dictionary<string, int>>();
+    private List<Dictionary<int, float>> playableParamterFloats = new List<Dictionary<int, float>>();
+    private List<Dictionary<int, int>> playableParamterInts = new List<Dictionary<int, int>>();
+    private List<Dictionary<int, bool>> playableParamterBools = new List<Dictionary<int, bool>>();
+    AnimationLayerMixerPlayable playableMixer;
+    PlayableGraph playableGraph;
+    VRCExpressionsMenu expressionsMenu;
+    VRCExpressionParameters stageParameters;
+    int sittingIndex, tposeIndex, ikposeIndex;
+    int fxIndex, altFXIndex;
+    int actionIndex, altActionIndex;
+    int additiveIndex, altAdditiveIndex;
+    int gestureIndex, altGestureIndex;
+
+    private int mouthOpenBlendShapeIdx;
+    private int[] visemeBlendShapeIdxs;
+
+    [NonSerialized] public VRCPhysBone[] AvDynamicsPhysBones = new VRCPhysBone[]{};
+    [NonSerialized] public VRCContactReceiver[] AvDynamicsContactReceivers = new VRCContactReceiver[]{};
+
+    public class Av3EmuParameterAccess : VRC.SDKBase.IAnimParameterAccess {
+        public LyumaAv3Runtime runtime;
+        public string paramName;
+        public bool boolVal {
+            get {
+                // Debug.Log(paramName + " GETb");
+                int idx;
+                if (runtime.IntToIndex.TryGetValue(paramName, out idx)) return runtime.Ints[idx].value != 0;
+                if (runtime.FloatToIndex.TryGetValue(paramName, out idx))return runtime.Floats[idx].exportedValue != 0.0f;
+                if (runtime.BoolToIndex.TryGetValue(paramName, out idx)) return runtime.Bools[idx].value;
+                return false;
+            }
+            set {
+                // Debug.Log(paramName + " SETb " + value);
+                int idx;
+                if (runtime.IntToIndex.TryGetValue(paramName, out idx)) runtime.Ints[idx].value = value ? 1 : 0;
+                if (runtime.FloatToIndex.TryGetValue(paramName, out idx)) {
+                    runtime.Floats[idx].value = value ? 1.0f : 0.0f;
+                    runtime.Floats[idx].exportedValue = runtime.Floats[idx].value;
+                }
+                if (runtime.BoolToIndex.TryGetValue(paramName, out idx)) runtime.Bools[idx].value = value;
+            }
+        }
+        public int intVal {
+            get {
+                int idx;
+                // Debug.Log(paramName + " GETi");
+                if (runtime.IntToIndex.TryGetValue(paramName, out idx)) return runtime.Ints[idx].value;
+                if (runtime.FloatToIndex.TryGetValue(paramName, out idx)) return (int)runtime.Floats[idx].exportedValue;
+                if (runtime.BoolToIndex.TryGetValue(paramName, out idx)) return runtime.Bools[idx].value ? 1 : 0;
+                return 0;
+            }
+            set {
+                // Debug.Log(paramName + " SETi " + value);
+                int idx;
+                if (runtime.IntToIndex.TryGetValue(paramName, out idx)) runtime.Ints[idx].value = value;
+                if (runtime.FloatToIndex.TryGetValue(paramName, out idx)) {
+                    runtime.Floats[idx].value = (float)value;
+                    runtime.Floats[idx].exportedValue = runtime.Floats[idx].value;
+                }
+                if (runtime.BoolToIndex.TryGetValue(paramName, out idx)) runtime.Bools[idx].value = value != 0;
+            }
+        }
+        public float floatVal {
+            get {
+                // Debug.Log(paramName + " GETf");
+                int idx;
+                if (runtime.IntToIndex.TryGetValue(paramName, out idx)) return (float)runtime.Ints[idx].value;
+                if (runtime.FloatToIndex.TryGetValue(paramName, out idx)) return runtime.Floats[idx].exportedValue;
+                if (runtime.BoolToIndex.TryGetValue(paramName, out idx)) return runtime.Bools[idx].value ? 1.0f : 0.0f;
+                return 0.0f;
+            }
+            set {
+                // Debug.Log(paramName + " SETf " + value);
+                int idx;
+                if (runtime.IntToIndex.TryGetValue(paramName, out idx)) runtime.Ints[idx].value = (int)value;
+                if (runtime.FloatToIndex.TryGetValue(paramName, out idx)) {
+                    runtime.Floats[idx].value = value;
+                    runtime.Floats[idx].exportedValue = value;
+                }
+                if (runtime.BoolToIndex.TryGetValue(paramName, out idx)) runtime.Bools[idx].value = value != 0.0f;
+            }
+        }
+    }
+
+    public void assignContactParameters(VRCContactReceiver[] behaviours) {
+        AvDynamicsContactReceivers = behaviours;
+        foreach (var mb in AvDynamicsContactReceivers) {
+            var old_value = mb.paramAccess;
+            if (old_value == null || old_value.GetType() != typeof(Av3EmuParameterAccess)) {
+                string parameter = mb.parameter;
+                Av3EmuParameterAccess accessInst = new Av3EmuParameterAccess();
+                accessInst.runtime = this;
+                accessInst.paramName = parameter;
+                mb.paramAccess = accessInst;
+                accessInst.floatVal = mb.paramValue;
+                // Debug.Log("Assigned access " + contactReceiverState.paramAccess.GetValue(mb) + " to param " + parameter + ": was " + old_value);
+            }
+        }
+    }
+    public void assignPhysBoneParameters(VRCPhysBone[] behaviours) {
+        AvDynamicsPhysBones = behaviours;
+        foreach (var mb in AvDynamicsPhysBones) {
+            var old_value = mb.param_Stretch;
+            if (old_value == null || old_value.GetType() != typeof(Av3EmuParameterAccess)) {
+                string parameter = mb.parameter;
+                Av3EmuParameterAccess accessInst = new Av3EmuParameterAccess();
+                accessInst.runtime = this;
+                accessInst.paramName = parameter + VRCPhysBone.PARAM_ANGLE;
+                mb.param_Angle = accessInst;
+                accessInst.floatVal = mb.param_AngleValue;
+                accessInst = new Av3EmuParameterAccess();
+                accessInst.runtime = this;
+                accessInst.paramName = parameter + VRCPhysBone.PARAM_ISGRABBED;
+                mb.param_IsGrabbed = accessInst;
+                accessInst.boolVal = mb.param_IsGrabbedValue;
+                accessInst = new Av3EmuParameterAccess();
+                accessInst.runtime = this;
+                accessInst.paramName = parameter + VRCPhysBone.PARAM_STRETCH;
+                mb.param_Stretch = accessInst;
+                accessInst.floatVal = mb.param_StretchValue;
+                // Debug.Log("Assigned strech access " + physBoneState.param_Stretch.GetValue(mb) + " to param " + parameter + ": was " + old_value);
+            }
+        }
+    }
+
+    public static float ClampFloatOnly(float val) {
+        if (val < -1.0f) {
+            val = -1.0f;
+        }
+        if (val > 1.0f) {
+            val = 1.0f;
+        }
+        return val;
+    }
+    public static float ClampAndQuantizeFloat(float val) {
+        val = ClampFloatOnly(val);
+        val *= 127.00f;
+        // if (val > 127.0f) {
+        //     val = 127.0f;
+        // }
+        val = Mathf.Round(val);
+        val = (((sbyte)val) / 127.0f);
+        val = ClampFloatOnly(val);
+        return val;
+    }
+    public static int ClampByte(int val) {
+        if (val < 0) {
+            val = 0;
+        }
+        if (val > 255) {
+            val = 255;
+        }
+        return val;
+    }
+
+    public enum VisemeIndex {
+        sil, PP, FF, TH, DD, kk, CH, SS, nn, RR, aa, E, I, O, U
+    }
+    public enum GestureIndex {
+        Neutral, Fist, HandOpen, Fingerpoint, Victory, RockNRoll, HandGun, ThumbsUp
+    }
+    public enum TrackingTypeIndex {
+        Uninitialized, GenericRig, NoFingers, HeadHands, HeadHandsHip, HeadHandsHipFeet = 6
+    }
+    public static HashSet<string> BUILTIN_PARAMETERS = new HashSet<string> {
+        "Viseme", "GestureLeft", "GestureLeftWeight", "GestureRight", "GestureRightWeight", "VelocityX", "VelocityY", "VelocityZ", "Upright", "AngularY", "Grounded", "Seated", "AFK", "TrackingType", "VRMode", "MuteSelf", "InStation"
+    };
+    public static readonly HashSet<Type> MirrorCloneComponentBlacklist = new HashSet<Type> {
+        typeof(Camera), typeof(FlareLayer), typeof(AudioSource), typeof(Rigidbody), typeof(Joint)
+    };
+    public static readonly HashSet<Type> ShadowCloneComponentBlacklist = new HashSet<Type> {
+        typeof(Camera), typeof(FlareLayer), typeof(AudioSource), typeof(Light), typeof(ParticleSystemRenderer), typeof(Rigidbody), typeof(Joint)
+    };
+    [Header("Built-in inputs / Viseme")]
+    public VisemeIndex Viseme;
+    [Range(0, 15)] public int VisemeIdx;
+    private int VisemeInt;
+    [Tooltip("Voice amount from 0.0f to 1.0f for the current viseme")]
+    [Range(0,1)] public float Voice;
+    [Header("Built-in inputs / Hand Gestures")]
+    public GestureIndex GestureLeft;
+    [Range(0, 9)] public int GestureLeftIdx;
+    private char GestureLeftIdxInt;
+    [Range(0, 1)] public float GestureLeftWeight;
+    private float OldGestureLeftWeight;
+    public GestureIndex GestureRight;
+    [Range(0, 9)] public int GestureRightIdx;
+    private char GestureRightIdxInt;
+    [Range(0, 1)] public float GestureRightWeight;
+    private float OldGestureRightWeight;
+    [Header("Built-in inputs / Locomotion")]
+    public Vector3 Velocity;
+    [Range(-400, 400)] public float AngularY;
+    [Range(0, 1)] public float Upright;
+    public bool Grounded;
+    public bool Jump;
+    public float JumpPower = 5;
+    public float RunSpeed = 0.0f;
+    private bool WasJump;
+    private Vector3 JumpingHeight;
+    private Vector3 JumpingVelocity;
+    private bool PrevSeated, PrevTPoseCalibration, PrevIKPoseCalibration;
+    public bool Seated;
+    public bool AFK;
+    public bool TPoseCalibration;
+    public bool IKPoseCalibration;
+    [Header("Built-in inputs / Tracking Setup and Other")]
+    public TrackingTypeIndex TrackingType;
+    [Range(0, 6)] public int TrackingTypeIdx;
+    private char TrackingTypeIdxInt;
+    public bool VRMode;
+    public bool MuteSelf;
+    private bool MuteTogglerOn;
+    public bool InStation;
+    [HideInInspector] public int AvatarVersion = 3;
+
+    [Header("Output State (Read-only)")]
+    public bool IsLocal;
+    [HideInInspector] public bool IsMirrorClone;
+    [HideInInspector] public bool IsShadowClone;
+    public bool LocomotionIsDisabled;
+
+    [Serializable]
+    public struct IKTrackingOutput {
+        public Vector3 HeadRelativeViewPosition;
+        public Vector3 ViewPosition;
+        public float AvatarScaleFactorGuess;
+        public VRCAnimatorTrackingControl.TrackingType trackingHead;
+        public VRCAnimatorTrackingControl.TrackingType trackingLeftHand;
+        public VRCAnimatorTrackingControl.TrackingType trackingRightHand;
+        public VRCAnimatorTrackingControl.TrackingType trackingHip;
+        public VRCAnimatorTrackingControl.TrackingType trackingLeftFoot;
+        public VRCAnimatorTrackingControl.TrackingType trackingRightFoot;
+        public VRCAnimatorTrackingControl.TrackingType trackingLeftFingers;
+        public VRCAnimatorTrackingControl.TrackingType trackingRightFingers;
+        public VRCAnimatorTrackingControl.TrackingType trackingEyesAndEyelids;
+        public VRCAnimatorTrackingControl.TrackingType trackingMouthAndJaw;
+    }
+    public IKTrackingOutput IKTrackingOutputData;
+
+    [Serializable]
+    public class FloatParam
+    {
+        [HideInInspector] public string stageName;
+        public string name;
+        [HideInInspector] public bool synced;
+        [Range(-1, 1)] public float expressionValue;
+        [HideInInspector] public float lastExpressionValue_;
+        [Range(-1, 1)] public float value;
+        [HideInInspector] private float exportedValue_;
+        public float exportedValue {
+            get {
+                return exportedValue_;
+            } set {
+                this.exportedValue_ = value;
+                this.value = value;
+                this.lastExpressionValue_ = value;
+                this.expressionValue = value;
+            }
+        }
+        [HideInInspector] public float lastValue;
+    }
+    [Header("User-generated inputs")]
+    public List<FloatParam> Floats = new List<FloatParam>();
+    public Dictionary<string, int> FloatToIndex = new Dictionary<string, int>();
+
+    [Serializable]
+    public class IntParam
+    {
+        [HideInInspector] public string stageName;
+        public string name;
+        [HideInInspector] public bool synced;
+        public int value;
+        [HideInInspector] public int lastValue;
+    }
+    public List<IntParam> Ints = new List<IntParam>();
+    public Dictionary<string, int> IntToIndex = new Dictionary<string, int>();
+
+    [Serializable]
+    public class BoolParam
+    {
+        [HideInInspector] public string stageName;
+
+        public string name;
+        [HideInInspector] public bool synced;
+        public bool value;
+        [HideInInspector] public bool lastValue;
+        [HideInInspector] public bool[] hasTrigger;
+        [HideInInspector] public bool[] hasBool;
+    }
+    public List<BoolParam> Bools = new List<BoolParam>();
+    public Dictionary<string, int> BoolToIndex = new Dictionary<string, int>();
+
+    public Dictionary<string, string> StageParamterToBuiltin = new Dictionary<string, string>();
+
+    [HideInInspector] public LyumaAv3Emulator emulator;
+
+    static public Dictionary<Animator, LyumaAv3Runtime> animatorToTopLevelRuntime = new Dictionary<Animator, LyumaAv3Runtime>();
+    private HashSet<Animator> attachedAnimators;
+    private HashSet<string> duplicateParameterAdds = new HashSet<string>();
+
+    const float BASE_HEIGHT = 1.4f;
+
+    public IEnumerator DelayedEnterPoseSpace(bool setView, float time) {
+        yield return new WaitForSeconds(time);
+        if (setView) {
+            Transform head = animator.GetBoneTransform(HumanBodyBones.Head);
+            if (head != null) {
+                IKTrackingOutputData.ViewPosition = animator.transform.InverseTransformPoint(head.TransformPoint(IKTrackingOutputData.HeadRelativeViewPosition));
+            }
+        } else {
+            IKTrackingOutputData.ViewPosition = avadesc.ViewPosition;
+        }
+    }
+
+    class BlendingState {
+        float startWeight;
+        float goalWeight;
+        float blendStartTime;
+        float blendDuration;
+        public bool blending;
+
+        public float UpdateBlending() {
+            if (blendDuration <= 0) {
+                blending = false;
+                return goalWeight;
+            }
+            float amt = (Time.time - blendStartTime) / blendDuration;
+            if (amt >= 1) {
+                blending = false;
+                return goalWeight;
+            }
+            return Mathf.Lerp(startWeight, goalWeight, amt);
+        }
+        public void StartBlend(float startWeight, float goalWeight, float duration) {
+            this.startWeight = startWeight;
+            this.blendDuration = duration;
+            this.blendStartTime = Time.time;
+            this.goalWeight = goalWeight;
+            this.blending = true;
+        }
+    }
+    class PlayableBlendingState : BlendingState {
+        public List<BlendingState> layerBlends = new List<BlendingState>();
+
+    }
+    List<PlayableBlendingState> playableBlendingStates = new List<PlayableBlendingState>();
+
+    static HashSet<Animator> issuedWarningAnimators = new HashSet<Animator>();
+    static bool getTopLevelRuntime(string component, Animator innerAnimator, out LyumaAv3Runtime runtime) {
+        if (animatorToTopLevelRuntime.TryGetValue(innerAnimator, out runtime)) {
+            return true;
+        }
+        Transform transform = innerAnimator.transform;
+        while (transform != null && runtime == null) {
+            runtime = transform.GetComponent<LyumaAv3Runtime>();
+            transform = transform.parent;
+        }
+        if (runtime != null) {
+            if (runtime.attachedAnimators != null) {
+                Debug.Log("[" + component + "]: " + innerAnimator + " found parent runtime after it was Awoken! Adding to cache. Did you move me?");
+                animatorToTopLevelRuntime.Add(innerAnimator, runtime);
+                runtime.attachedAnimators.Add(innerAnimator);
+            } else {
+                Debug.Log("[" + component + "]: " + innerAnimator + " found parent runtime without being Awoken! Wakey Wakey...", runtime);
+                runtime.Awake();
+            }
+            return true;
+        }
+
+        if (!issuedWarningAnimators.Contains(innerAnimator))
+        {
+            issuedWarningAnimators.Add(innerAnimator);
+            Debug.LogWarning("[" + component + "]: outermost Animator is not known: " + innerAnimator + ". If you changed something, consider resetting avatar", innerAnimator);
+        }
+
+        return false;
+    }
+
+    float getAdjustedParameterAsFloat(string paramName, bool convertRange=false, float srcMin=0.0f, float srcMax=0.0f, float dstMin=0.0f, float dstMax=0.0f) {
+        float newValue = 0;
+        int idx;
+        if (FloatToIndex.TryGetValue(paramName, out idx)) {
+            newValue = Floats[idx].exportedValue;
+        } else if (IntToIndex.TryGetValue(paramName, out idx)) {
+            newValue = (float)Ints[idx].value;
+        } else if (BoolToIndex.TryGetValue(paramName, out idx)) {
+            newValue = Bools[idx].value ? 1.0f : 0.0f;
+        }
+        if (convertRange) {
+            if (dstMax != dstMin) {
+                newValue = Mathf.Lerp(dstMin, dstMax, Mathf.Clamp01(Mathf.InverseLerp(srcMin, srcMax, newValue)));
+            } else {
+                newValue = dstMin;
+            }
+        }
+        return newValue;
+    }
+
+    static LyumaAv3Runtime() {
+        VRCAvatarParameterDriver.OnApplySettings += (behaviour, animator) =>
+            {
+                LyumaAv3Runtime runtime;
+                if (!getTopLevelRuntime("VRCAvatarParameterDriver", animator, out runtime)) {
+                    return;
+                }
+                if (runtime.IsMirrorClone || runtime.IsShadowClone) {
+                    return;
+                }
+                if (behaviour.debugString != null && behaviour.debugString.Length > 0)
+                {
+                    Debug.Log("[VRCAvatarParameterDriver:" + (runtime == null ? "null" : runtime.name) + "]" + behaviour.name + ": " + behaviour.debugString, behaviour);
+                }
+                if (!runtime)
+                {
+                    return;
+                }
+                if (animator != runtime.animator && (!runtime.emulator || !runtime.emulator.legacySubAnimatorParameterDriverMode)) {
+                    return;
+                }
+                if (!runtime.IsLocal && behaviour.localOnly) {
+                    return;
+                }
+                HashSet<string> newParameterAdds = new HashSet<string>();
+                HashSet<string> deleteParameterAdds = new HashSet<string>();
+                foreach (var parameter in behaviour.parameters) {
+                    if (runtime.DebugDuplicateAnimator != VRCAvatarDescriptor.AnimLayerType.Base && !runtime.IsMirrorClone && !runtime.IsShadowClone && (parameter.type == VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Add || parameter.type == VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Random)) {
+                        string dupeKey = parameter.value + ((parameter.type == VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Add) ? "add " : "rand ") + parameter.name;
+                        if (!runtime.duplicateParameterAdds.Contains(dupeKey)) {
+                            newParameterAdds.Add(dupeKey);
+                            continue;
+                        }
+                        deleteParameterAdds.Add(dupeKey);
+                    }
+                    string actualName = parameter.name;
+                    int idx;
+                    if (runtime.IntToIndex.TryGetValue(actualName, out idx)) {
+                        switch (parameter.type) {
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Set:
+                                runtime.Ints[idx].value = (int)parameter.value;
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Add:
+                                runtime.Ints[idx].value += (int)parameter.value;
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Random:
+                                runtime.Ints[idx].value = UnityEngine.Random.Range((int)parameter.valueMin, (int)parameter.valueMax + 1);
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Copy:
+                                runtime.Ints[idx].value = (int)runtime.getAdjustedParameterAsFloat(parameter.source, parameter.convertRange, parameter.sourceMin, parameter.sourceMax, parameter.destMin, parameter.destMax);
+                                break;
+                        }
+                    }
+                    if (runtime.FloatToIndex.TryGetValue(actualName, out idx)) {
+                        switch (parameter.type) {
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Set:
+                                runtime.Floats[idx].exportedValue = parameter.value;
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Add:
+                                runtime.Floats[idx].exportedValue += parameter.value;
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Random:
+                                runtime.Floats[idx].exportedValue = UnityEngine.Random.Range(parameter.valueMin, parameter.valueMax);
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Copy:
+                                runtime.Floats[idx].exportedValue = runtime.getAdjustedParameterAsFloat(parameter.source, parameter.convertRange, parameter.sourceMin, parameter.sourceMax, parameter.destMin, parameter.destMax);
+                                break;
+                        }
+                        runtime.Floats[idx].value = runtime.Floats[idx].exportedValue;
+                    }
+                    if (runtime.BoolToIndex.TryGetValue(actualName, out idx)) {
+                        bool newValue;
+                        BoolParam bp = runtime.Bools[idx];
+                        int whichController;
+                        // bp.value = parameter.value != 0;
+                        switch (parameter.type) {
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Set:
+                                newValue = parameter.value != 0.0f;
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Add:
+                                /* editor script treats it as random, but it is its own operation */
+                                newValue = ((bp.value ? 1.0 : 0.0) + parameter.value) != 0.0f; // weird but ok...
+                                // Debug.Log("Add bool " + bp.name + " to " + newValue + ", " + (bp.value ? 1.0 : 0.0) + ", " + parameter.value);
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Random:
+                                // random is *not* idempotent.
+                                newValue = UnityEngine.Random.Range(0.0f, 1.0f) < parameter.chance;
+                                break;
+                            case VRC.SDKBase.VRC_AvatarParameterDriver.ChangeType.Copy:
+                                newValue = runtime.getAdjustedParameterAsFloat(parameter.source, parameter.convertRange, parameter.sourceMin, parameter.sourceMax, parameter.destMin, parameter.destMax) != 0.0f;
+                                break;
+                            default:
+                                continue;
+                        }
+                        if (!bp.synced) {
+                            // Triggers ignore alue and Set unconditionally.
+                            whichController = 0;
+                            foreach (var p in runtime.playables) {
+                                if (bp.hasBool[whichController]) {
+                                    p.SetBool(actualName, newValue);
+                                }
+                                whichController++;
+                            }
+                            whichController = 0;
+                            foreach (var p in runtime.playables) {
+                                if (bp.hasTrigger[whichController]) {
+                                    p.SetTrigger(actualName);
+                                }
+                                whichController++;
+                            }
+                            bp.lastValue = newValue;
+                        }
+                        bp.value = newValue;
+                    }
+                }
+                foreach (var key in deleteParameterAdds) {
+                    runtime.duplicateParameterAdds.Remove(key);
+                }
+                foreach (var key in newParameterAdds) {
+                    runtime.duplicateParameterAdds.Add(key);
+                }
+            };
+        VRCPlayableLayerControl.Initialize += (x) => {
+            x.ApplySettings += (behaviour, animator) =>
+            {
+                LyumaAv3Runtime runtime;
+                if (!getTopLevelRuntime("VRCPlayableLayerControl", animator, out runtime)) {
+                    return;
+                }
+                if (runtime.IsMirrorClone && runtime.IsShadowClone) {
+                    return;
+                }
+                if (behaviour.debugString != null && behaviour.debugString.Length > 0)
+                {
+                    Debug.Log("[VRCPlayableLayerControl:" + (runtime == null ? "null" : runtime.name) + "]" + behaviour.name + ": " + behaviour.debugString, behaviour);
+                }
+                if (!runtime)
+                {
+                    return;
+                }
+                int idx = -1;
+                switch (behaviour.layer)
+                {
+                    case VRCPlayableLayerControl.BlendableLayer.Action:
+                        idx = runtime.actionIndex;
+                        break;
+                    case VRCPlayableLayerControl.BlendableLayer.Additive:
+                        idx = runtime.additiveIndex;
+                        break;
+                    case VRCPlayableLayerControl.BlendableLayer.FX:
+                        idx = runtime.fxIndex;
+                        break;
+                    case VRCPlayableLayerControl.BlendableLayer.Gesture:
+                        idx = runtime.gestureIndex;
+                        break;
+                }
+                if (idx >= 0 && idx < runtime.playableBlendingStates.Count)
+                {
+                    runtime.playableBlendingStates[idx].StartBlend(runtime.playableMixer.GetInputWeight(idx + 1), behaviour.goalWeight, behaviour.blendDuration);
+                    // Debug.Log("Start blend of whole playable " + idx + " from " + runtime.playableMixer.GetInputWeight(idx + 1) + " to " + behaviour.goalWeight);
+                }
+            };
+        };
+        VRCAnimatorLayerControl.Initialize += (x) => {
+            x.ApplySettings += (behaviour, animator) =>
+            {
+                LyumaAv3Runtime runtime;
+                if (!getTopLevelRuntime("VRCAnimatorLayerControl", animator, out runtime)) {
+                    return;
+                }
+                if (runtime.IsMirrorClone) {
+                    return;
+                }
+                if (behaviour.debugString != null && behaviour.debugString.Length > 0)
+                {
+                    Debug.Log("[VRCAnimatorLayerControl:" + (runtime == null ? "null" : runtime.name) + "]" + behaviour.name + ": " + behaviour.debugString, behaviour);
+                }
+                if (!runtime)
+                {
+                    return;
+                }
+                int idx = -1, altidx = -1;
+                switch (behaviour.playable)
+                {
+                    case VRCAnimatorLayerControl.BlendableLayer.Action:
+                        idx = runtime.actionIndex;
+                        altidx = runtime.altActionIndex;
+                        break;
+                    case VRCAnimatorLayerControl.BlendableLayer.Additive:
+                        idx = runtime.additiveIndex;
+                        altidx = runtime.altAdditiveIndex;
+                        break;
+                    case VRCAnimatorLayerControl.BlendableLayer.FX:
+                        idx = runtime.fxIndex;
+                        altidx = runtime.altFXIndex;
+                        break;
+                    case VRCAnimatorLayerControl.BlendableLayer.Gesture:
+                        idx = runtime.gestureIndex;
+                        altidx = runtime.altGestureIndex;
+                        break;
+                }
+                if (idx >= 0 && idx < runtime.playableBlendingStates.Count)
+                {
+                    if (behaviour.layer >= 0 && behaviour.layer < runtime.playableBlendingStates[idx].layerBlends.Count)
+                    {
+                        runtime.playableBlendingStates[idx].layerBlends[behaviour.layer].StartBlend(runtime.playables[idx].GetLayerWeight(behaviour.layer), behaviour.goalWeight, behaviour.blendDuration);
+                        // Debug.Log("Start blend of playable " + idx + " layer " + behaviour.layer + " from " + runtime.playables[idx].GetLayerWeight(behaviour.layer) + " to " + behaviour.goalWeight);
+                        if (altidx >= 0) {
+                            runtime.playableBlendingStates[altidx].layerBlends[behaviour.layer].StartBlend(runtime.playables[altidx].GetLayerWeight(behaviour.layer), behaviour.goalWeight, behaviour.blendDuration);
+                            // Debug.Log("Start blend of alt playable " + altidx + " layer " + behaviour.layer + " from " + runtime.playables[altidx].GetLayerWeight(behaviour.layer) + " to " + behaviour.goalWeight);
+                        }
+                    }
+                }
+            };
+        };
+        VRCAnimatorLocomotionControl.Initialize += (x) => {
+            x.ApplySettings += (behaviour, animator) =>
+            {
+                LyumaAv3Runtime runtime;
+                if (!getTopLevelRuntime("VRCAnimatorLocomotionControl", animator, out runtime)) {
+                    return;
+                }
+                if (runtime.IsMirrorClone && runtime.IsShadowClone) {
+                    return;
+                }
+                if (behaviour.debugString != null && behaviour.debugString.Length > 0)
+                {
+                    Debug.Log("[VRCAnimatorLocomotionControl:" + (runtime == null ? "null" : runtime.name) + "]" + behaviour.name + ": " + behaviour.debugString, behaviour);
+                }
+                if (!runtime)
+                {
+                    return;
+                }
+                // I legit don't know
+                runtime.LocomotionIsDisabled = behaviour.disableLocomotion;
+            };
+        };
+        VRCAnimatorTemporaryPoseSpace.Initialize += (x) => {
+            x.ApplySettings += (behaviour, animator) =>
+            {
+                LyumaAv3Runtime runtime;
+                if (!getTopLevelRuntime("VRCAnimatorSetView", animator, out runtime)) {
+                    return;
+                }
+                if (runtime.IsMirrorClone && runtime.IsShadowClone) {
+                    return;
+                }
+                if (behaviour.debugString != null && behaviour.debugString.Length > 0)
+                {
+                    Debug.Log("[VRCAnimatorSetView:" + (runtime == null ? "null" : runtime.name) + "]" + behaviour.name + ": " + behaviour.debugString, behaviour);
+                }
+                if (!runtime)
+                {
+                    return;
+                }
+                // fixedDelay: Is the delay fixed or normalized...
+                // The layerIndex is not passed into the delegate, so we cannot reimplement fixedDelay.
+                runtime.StartCoroutine(runtime.DelayedEnterPoseSpace(behaviour.enterPoseSpace, behaviour.delayTime));
+            };
+        };
+        VRCAnimatorTrackingControl.Initialize += (x) => {
+            x.ApplySettings += (behaviour, animator) =>
+            {
+                LyumaAv3Runtime runtime;
+                if (!getTopLevelRuntime("VRCAnimatorTrackingControl", animator, out runtime)) {
+                    return;
+                }
+                if (runtime.IsMirrorClone && runtime.IsShadowClone) {
+                    return;
+                }
+                if (behaviour.debugString != null && behaviour.debugString.Length > 0)
+                {
+                    Debug.Log("[VRCAnimatorTrackingControl:" + (runtime == null ? "null" : runtime.name) + "]" + behaviour.name + ": " + behaviour.debugString, behaviour);
+                }
+                if (!runtime)
+                {
+                    return;
+                }
+
+                if (behaviour.trackingMouth != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingMouthAndJaw = behaviour.trackingMouth;
+                }
+                if (behaviour.trackingHead != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingHead = behaviour.trackingHead;
+                }
+                if (behaviour.trackingRightFingers != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingRightFingers = behaviour.trackingRightFingers;
+                }
+                if (behaviour.trackingEyes != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingEyesAndEyelids = behaviour.trackingEyes;
+                }
+                if (behaviour.trackingLeftFingers != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingLeftFingers = behaviour.trackingLeftFingers;
+                }
+                if (behaviour.trackingLeftFoot != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingLeftFoot = behaviour.trackingLeftFoot;
+                }
+                if (behaviour.trackingHip != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingHip = behaviour.trackingHip;
+                }
+                if (behaviour.trackingRightHand != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingRightHand = behaviour.trackingRightHand;
+                }
+                if (behaviour.trackingLeftHand != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingLeftHand = behaviour.trackingLeftHand;
+                }
+                if (behaviour.trackingRightFoot != VRCAnimatorTrackingControl.TrackingType.NoChange)
+                {
+                    runtime.IKTrackingOutputData.trackingRightFoot = behaviour.trackingRightFoot;
+                }
+            };
+        };
+    }
+
+    void OnDestroy () {
+        if (this.playableGraph.IsValid()) {
+            this.playableGraph.Destroy();
+        }
+        if (attachedAnimators != null) {
+            foreach (var anim in attachedAnimators) {
+                LyumaAv3Runtime runtime;
+                if (animatorToTopLevelRuntime.TryGetValue(anim, out runtime) && runtime == this)
+                {
+                    animatorToTopLevelRuntime.Remove(anim);
+                }
+            }
+        }
+        if (animator != null) {
+            if (animator.playableGraph.IsValid())
+            {
+                animator.playableGraph.Destroy();
+            }
+            animator.runtimeAnimatorController = origAnimatorController;
+        }
+    }
+
+    void Awake()
+    {
+        if (AvatarSyncSource != null && OriginalSourceClone == null) {
+            Debug.Log("Awake returning early for " + gameObject.name, this);
+            return;
+        }
+        if (attachedAnimators != null) {
+            Debug.Log("Deduplicating Awake() call if we already got awoken by our children.", this);
+            return;
+        }
+        // Debug.Log("AWOKEN " + gameObject.name, this);
+        attachedAnimators = new HashSet<Animator>();
+        if (AvatarSyncSource == null) {
+            var oml = GetComponent<UnityEngine.AI.OffMeshLink>();
+            if (oml != null && oml.startTransform != null) {
+                this.emulator = oml.startTransform.GetComponent<LyumaAv3Emulator>();
+                GameObject.DestroyImmediate(oml);
+            }
+            Transform transform = this.transform;
+            SourceObjectPath = "";
+            while (transform != null) {
+                SourceObjectPath = "/" + transform.name + SourceObjectPath;
+                transform = transform.parent;
+            }
+            AvatarSyncSource = this;
+        } else {
+            AvatarSyncSource = GameObject.Find(SourceObjectPath).GetComponent<LyumaAv3Runtime>();
+        }
+
+        if (this.emulator != null) {
+            DebugDuplicateAnimator = this.emulator.DefaultAnimatorToDebug;
+            ViewAnimatorOnlyNoParams = this.emulator.DefaultAnimatorToDebug;
+        }
+
+        animator = this.gameObject.GetOrAddComponent<Animator>();
+        if (animatorAvatar != null && animator.avatar == null) {
+            animator.avatar = animatorAvatar;
+        } else {
+            animatorAvatar = animator.avatar;
+        }
+        // Default values.
+        Grounded = true;
+        Upright = 1.0f;
+        if (!animator.isHuman) {
+            TrackingType = TrackingTypeIndex.GenericRig;
+        } else if (!VRMode) {
+            TrackingType = TrackingTypeIndex.HeadHands;
+        }
+        avadesc = this.gameObject.GetComponent<VRCAvatarDescriptor>();
+        if (avadesc.VisemeSkinnedMesh == null) {
+            mouthOpenBlendShapeIdx = -1;
+            visemeBlendShapeIdxs = new int[0];
+        } else {
+            mouthOpenBlendShapeIdx = avadesc.VisemeSkinnedMesh.sharedMesh.GetBlendShapeIndex(avadesc.MouthOpenBlendShapeName);
+            visemeBlendShapeIdxs = new int[avadesc.VisemeBlendShapes == null ? 0 : avadesc.VisemeBlendShapes.Length];
+            if (avadesc.VisemeBlendShapes != null) {
+                for (int i = 0; i < avadesc.VisemeBlendShapes.Length; i++) {
+                    visemeBlendShapeIdxs[i] = avadesc.VisemeSkinnedMesh.sharedMesh.GetBlendShapeIndex(avadesc.VisemeBlendShapes[i]);
+                }
+            }
+        }
+        bool shouldClone = false;
+        if (OriginalSourceClone == null) {
+            OriginalSourceClone = this;
+            shouldClone = true;
+        }
+        if (shouldClone && GetComponent<PipelineSaver>() == null) {
+            GameObject cloned = GameObject.Instantiate(gameObject);
+            cloned.hideFlags = HideFlags.HideAndDontSave;
+            cloned.SetActive(false);
+            OriginalSourceClone = cloned.GetComponent<LyumaAv3Runtime>();
+            Debug.Log("Spawned a hidden source clone " + OriginalSourceClone, OriginalSourceClone);
+            OriginalSourceClone.OriginalSourceClone = OriginalSourceClone;
+        }
+        foreach (var smr in gameObject.GetComponentsInChildren<SkinnedMeshRenderer>(true)) {
+            smr.updateWhenOffscreen = (AvatarSyncSource == this || IsMirrorClone || IsShadowClone);
+        }
+        int desiredLayer = 9;
+        if (AvatarSyncSource == this) {
+            desiredLayer = 10;
+        }
+        if (IsMirrorClone) {
+            desiredLayer = 18;
+        }
+        if (IsShadowClone) {
+            desiredLayer = 9; // the Shadowclone is always on playerLocal and never on UI Menu
+        }
+        if (gameObject.layer != 12 || desiredLayer == 18) {
+            gameObject.layer = desiredLayer;
+        }
+        allTransforms = gameObject.GetComponentsInChildren<Transform>(true);
+        foreach (Transform t in allTransforms) {
+            if (t.gameObject.layer != 12 || desiredLayer == 18) {
+                t.gameObject.layer = desiredLayer;
+            }
+        }
+
+        InitializeAnimator();
+        if (addRuntimeDelegate != null) {
+            addRuntimeDelegate(this);
+        }
+        if (AvatarSyncSource == this) {
+            CreateAv3MenuComponent();
+        }
+        if (this.AvatarSyncSource != this || IsMirrorClone || IsShadowClone) {
+            PrevAnimatorToViewLiteParamsShow0 = (char)(int)ViewAnimatorOnlyNoParams;
+        }
+        if (!IsMirrorClone && !IsShadowClone && AvatarSyncSource == this) {
+            var pipelineManager = avadesc.GetComponent<VRC.Core.PipelineManager>();
+            string avatarid = pipelineManager != null ? pipelineManager.blueprintId : null;
+           OSCConfigurationFile.EnsureOSCJSONConfig(avadesc.expressionParameters, avatarid, this.gameObject.name);
+        }
+    }
+
+    public void CreateMirrorClone() {
+        if (AvatarSyncSource == this && GetComponent<PipelineSaver>() == null) {
+            OriginalSourceClone.IsMirrorClone = true;
+            MirrorClone = GameObject.Instantiate(OriginalSourceClone.gameObject).GetComponent<LyumaAv3Runtime>();
+            MirrorClone.GetComponent<Animator>().avatar = null;
+            OriginalSourceClone.IsMirrorClone = false;
+            GameObject o = MirrorClone.gameObject;
+            o.name = gameObject.name + " (MirrorReflection)";
+            o.SetActive(true);
+            allMirrorTransforms = MirrorClone.gameObject.GetComponentsInChildren<Transform>(true);
+            foreach (Component component in MirrorClone.gameObject.GetComponentsInChildren<Component>(true)) {
+                if (MirrorCloneComponentBlacklist.Contains(component.GetType()) || component.GetType().ToString().Contains("DynamicBone")
+                         || component.GetType().ToString().Contains("VRCContact") || component.GetType().ToString().Contains("VRCPhysBone")) {
+                    UnityEngine.Object.Destroy(component);
+                }
+            }
+        }
+    }
+
+    public void CreateShadowClone() {
+        if (AvatarSyncSource == this && GetComponent<PipelineSaver>() == null) {
+            OriginalSourceClone.IsShadowClone = true;
+            ShadowClone = GameObject.Instantiate(OriginalSourceClone.gameObject).GetComponent<LyumaAv3Runtime>();
+            ShadowClone.GetComponent<Animator>().avatar = null;
+            OriginalSourceClone.IsShadowClone = false;
+            GameObject o = ShadowClone.gameObject;
+            o.name = gameObject.name + " (ShadowClone)";
+            o.SetActive(true);
+            allShadowTransforms = ShadowClone.gameObject.GetComponentsInChildren<Transform>(true);
+            foreach (Component component in ShadowClone.gameObject.GetComponentsInChildren<Component>(true)) {
+                if (ShadowCloneComponentBlacklist.Contains(component.GetType()) || component.GetType().ToString().Contains("DynamicBone")
+                         || component.GetType().ToString().Contains("VRCContact") || component.GetType().ToString().Contains("VRCPhysBone")) {
+                    UnityEngine.Object.Destroy(component);
+                    continue;
+                }
+                if (component.GetType() == typeof(SkinnedMeshRenderer) || component.GetType() == typeof(MeshRenderer)) {
+                    Renderer renderer = component as Renderer;
+                    renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly; // ShadowCastingMode.TwoSided isn't accounted for and does not work locally
+                }
+            }
+            foreach (Renderer renderer in gameObject.GetComponentsInChildren<Renderer>(true)) {
+                renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; // ShadowCastingMode.TwoSided isn't accounted for and does not work locally
+            }
+        }
+    }
+
+    private void InitializeAnimator()
+    {
+        ResetAvatar = false;
+        PrevAnimatorToDebug = (char)(int)DebugDuplicateAnimator;
+        ViewAnimatorOnlyNoParams = DebugDuplicateAnimator;
+
+        animator = this.gameObject.GetOrAddComponent<Animator>();
+        animator.avatar = animatorAvatar;
+        animator.applyRootMotion = false;
+        animator.updateMode = AnimatorUpdateMode.Normal;
+        animator.cullingMode = (this == AvatarSyncSource || IsMirrorClone || IsShadowClone) ? AnimatorCullingMode.AlwaysAnimate : AnimatorCullingMode.CullCompletely;
+        animator.runtimeAnimatorController = null;
+
+        avadesc = this.gameObject.GetComponent<VRCAvatarDescriptor>();
+        IKTrackingOutputData.ViewPosition = avadesc.ViewPosition;
+        IKTrackingOutputData.AvatarScaleFactorGuess = IKTrackingOutputData.ViewPosition.magnitude / BASE_HEIGHT; // mostly guessing...
+        IKTrackingOutputData.HeadRelativeViewPosition = IKTrackingOutputData.ViewPosition;
+        if (animator.avatar != null)
+        {
+            Transform head = animator.GetBoneTransform(HumanBodyBones.Head);
+            if (head != null) {
+                IKTrackingOutputData.HeadRelativeViewPosition = head.InverseTransformPoint(animator.transform.TransformPoint(IKTrackingOutputData.ViewPosition));
+            }
+        }
+        expressionsMenu = avadesc.expressionsMenu;
+        stageParameters = avadesc.expressionParameters;
+        if (origAnimatorController != null) {
+            origAnimatorController = animator.runtimeAnimatorController;
+        }
+
+        VRCAvatarDescriptor.CustomAnimLayer[] baselayers = avadesc.baseAnimationLayers;
+        VRCAvatarDescriptor.CustomAnimLayer[] speciallayers = avadesc.specialAnimationLayers;
+        List<VRCAvatarDescriptor.CustomAnimLayer> allLayers = new List<VRCAvatarDescriptor.CustomAnimLayer>();
+        // foreach (VRCAvatarDescriptor.CustomAnimLayer cal in baselayers) {
+        //     if (AnimatorToDebug == cal.type) {
+        //         allLayers.Add(cal);
+        //     }
+        // }
+        // foreach (VRCAvatarDescriptor.CustomAnimLayer cal in speciallayers) {
+        //     if (AnimatorToDebug == cal.type) {
+        //         allLayers.Add(cal);
+        //     }
+        // }
+        int i = 0;
+        if (DebugDuplicateAnimator != VRCAvatarDescriptor.AnimLayerType.Base && !IsMirrorClone && !IsShadowClone) {
+            foreach (VRCAvatarDescriptor.CustomAnimLayer cal in baselayers) {
+                if (DebugDuplicateAnimator == cal.type) {
+                    i++;
+                    allLayers.Add(cal);
+                    break;
+                }
+            }
+            foreach (VRCAvatarDescriptor.CustomAnimLayer cal in speciallayers) {
+                if (DebugDuplicateAnimator == cal.type) {
+                    i++;
+                    allLayers.Add(cal);
+                    break;
+                }
+            }
+            // WE ADD ALL THE LAYERS A SECOND TIME BECAUSE!
+            // Add and Random Parameter drivers are not idepotent.
+            // To solve this, we ignore every other invocation.
+            // Therefore, we must add all layers twice, not just the one we are debugging...???
+            foreach (VRCAvatarDescriptor.CustomAnimLayer cal in baselayers) {
+                if (DebugDuplicateAnimator != cal.type) {
+                    i++;
+                    allLayers.Add(cal);
+                }
+            }
+            foreach (VRCAvatarDescriptor.CustomAnimLayer cal in speciallayers) {
+                if (DebugDuplicateAnimator != cal.type) {
+                    i++;
+                    allLayers.Add(cal);
+                }
+            }
+        }
+        int dupeOffset = i;
+        if (!IsMirrorClone && !IsShadowClone) {
+            foreach (VRCAvatarDescriptor.CustomAnimLayer cal in baselayers) {
+                if (cal.type == VRCAvatarDescriptor.AnimLayerType.Base || cal.type == VRCAvatarDescriptor.AnimLayerType.Additive) {
+                    i++;
+                    allLayers.Add(cal);
+                }
+            }
+            foreach (VRCAvatarDescriptor.CustomAnimLayer cal in speciallayers) {
+                i++;
+                allLayers.Add(cal);
+            }
+        }
+        foreach (VRCAvatarDescriptor.CustomAnimLayer cal in baselayers) {
+            if (IsMirrorClone || IsShadowClone) {
+                if (cal.type == VRCAvatarDescriptor.AnimLayerType.FX) {
+                    i++;
+                    allLayers.Add(cal);
+                }
+            } else if (!(cal.type == VRCAvatarDescriptor.AnimLayerType.Base || cal.type == VRCAvatarDescriptor.AnimLayerType.Additive)) {
+                i++;
+                allLayers.Add(cal);
+            }
+        }
+
+        if (playableGraph.IsValid()) {
+            playableGraph.Destroy();
+        }
+        playables.Clear();
+        playableBlendingStates.Clear();
+
+        for (i = 0; i < allLayers.Count; i++) {
+            playables.Add(new AnimatorControllerPlayable());
+            playableBlendingStates.Add(null);
+        }
+
+        actionIndex = fxIndex = gestureIndex = additiveIndex = sittingIndex = ikposeIndex = tposeIndex = -1;
+        altActionIndex = altFXIndex = altGestureIndex = altAdditiveIndex = -1;
+
+        foreach (var anim in attachedAnimators) {
+            LyumaAv3Runtime runtime;
+            if (animatorToTopLevelRuntime.TryGetValue(anim, out runtime) && runtime == this)
+            {
+                animatorToTopLevelRuntime.Remove(anim);
+            }
+        }
+        attachedAnimators.Clear();
+        Animator[] animators = this.gameObject.GetComponentsInChildren<Animator>(true);
+        foreach (Animator anim in animators)
+        {
+            attachedAnimators.Add(anim);
+            animatorToTopLevelRuntime.Add(anim, this);
+        }
+
+        Dictionary<string, float> stageNameToValue = EarlyRefreshExpressionParameters();
+        if (animator.playableGraph.IsValid())
+        {
+            animator.playableGraph.Destroy();
+        }
+        // var director = avadesc.gameObject.GetComponent<PlayableDirector>();
+        playableGraph = PlayableGraph.Create("LyumaAvatarRuntime - " + this.gameObject.name);
+        var externalOutput = AnimationPlayableOutput.Create(playableGraph, "ExternalAnimator", animator);
+        playableMixer = AnimationLayerMixerPlayable.Create(playableGraph, allLayers.Count + 1);
+        externalOutput.SetSourcePlayable(playableMixer);
+        animator.applyRootMotion = false;
+
+        i = 0;
+        // playableMixer.ConnectInput(0, AnimatorControllerPlayable.Create(playableGraph, allLayers[layerToDebug - 1].animatorController), 0, 0);
+        foreach (VRCAvatarDescriptor.CustomAnimLayer vrcAnimLayer in allLayers)
+        {
+            i++; // Ignore zeroth layer.
+            bool additive = (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.Additive);
+            RuntimeAnimatorController ac = null;
+            AvatarMask mask;
+            if (vrcAnimLayer.isDefault) {
+                ac = animLayerToDefaultController[vrcAnimLayer.type];
+                mask = animLayerToDefaultAvaMask[vrcAnimLayer.type];
+            } else
+            {
+                ac = vrcAnimLayer.animatorController;
+                mask = vrcAnimLayer.mask;
+                if (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.FX) {
+                    mask = animLayerToDefaultAvaMask[vrcAnimLayer.type]; // Force mask to prevent muscle overrides.
+                }
+            }
+            if (ac == null) {
+                Debug.Log(vrcAnimLayer.type + " controller is null: continue.");
+                // i was incremented, but one of the playableMixer inputs is left unconnected.
+                continue;
+            }
+            allControllers[vrcAnimLayer.type] = ac;
+            AnimatorControllerPlayable humanAnimatorPlayable = AnimatorControllerPlayable.Create(playableGraph, ac);
+            PlayableBlendingState pbs = new PlayableBlendingState();
+            for (int j = 0; j < humanAnimatorPlayable.GetLayerCount(); j++)
+            {
+                pbs.layerBlends.Add(new BlendingState());
+            }
+
+            // If we are debugging a particular layer, we must put that first.
+            // The Animator Controller window only shows the first layer.
+            int effectiveIdx = i;
+
+            playableMixer.ConnectInput((int)effectiveIdx, humanAnimatorPlayable, 0, 1);
+            playables[effectiveIdx - 1] = humanAnimatorPlayable;
+            playableBlendingStates[effectiveIdx - 1] = pbs;
+            if (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.Sitting) {
+                if (i >= dupeOffset) {
+                    sittingIndex = effectiveIdx - 1;
+                }
+                playableMixer.SetInputWeight(effectiveIdx, 0f);
+            }
+            if (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.IKPose)
+            {
+                if (i >= dupeOffset) {
+                    ikposeIndex = effectiveIdx - 1;
+                }
+                playableMixer.SetInputWeight(effectiveIdx, 0f);
+            }
+            if (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.TPose)
+            {
+                if (i >= dupeOffset) {
+                    tposeIndex = effectiveIdx - 1;
+                }
+                playableMixer.SetInputWeight(effectiveIdx, 0f);
+            }
+            if (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.Action)
+            {
+                playableMixer.SetInputWeight(i, 0f);
+                if (i < dupeOffset) {
+                    altActionIndex = effectiveIdx - 1;
+                } else {
+                    actionIndex = effectiveIdx - 1;
+                }
+
+            }
+            if (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.Gesture) {
+                if (i < dupeOffset) {
+                    altGestureIndex = effectiveIdx - 1;
+                } else {
+                    gestureIndex = effectiveIdx - 1;
+                }
+
+            }
+            if (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.Additive)
+            {
+                if (i < dupeOffset) {
+                    altAdditiveIndex = effectiveIdx - 1;
+                } else {
+                    additiveIndex = effectiveIdx - 1;
+                }
+
+            }
+            if (vrcAnimLayer.type == VRCAvatarDescriptor.AnimLayerType.FX)
+            {
+                if (i < dupeOffset) {
+                    altFXIndex = effectiveIdx - 1;
+                } else {
+                    fxIndex = effectiveIdx - 1;
+                }
+            }
+            // AnimationControllerLayer acLayer = new AnimationControllerLayer()
+            if (mask != null)
+            {
+                playableMixer.SetLayerMaskFromAvatarMask((uint)effectiveIdx, mask);
+            }
+            if (additive)
+            {
+                playableMixer.SetLayerAdditive((uint)effectiveIdx, true);
+            }
+
+            // Keep weight 1.0 if (i < dupeOffset).
+            // Layers have incorrect AAP values if playable weight is 0.0...
+            // and the duplicate layers will be overridden later anyway by Base.
+        }
+
+        LateRefreshExpressionParameters(stageNameToValue);
+
+        // Plays the Graph.
+        playableGraph.SetTimeUpdateMode(DirectorUpdateMode.GameTime);
+        Debug.Log(this.name + " : " + GetType() + " awoken and ready to Play.", this);
+        playableGraph.Play();
+    }
+
+    Dictionary<string, float> EarlyRefreshExpressionParameters() {
+        Dictionary<string, float> stageNameToValue = new Dictionary<string, float>();
+        if (IsLocal) {
+            foreach (var val in Ints) {
+                stageNameToValue[val.stageName] = val.value;
+            }
+            foreach (var val in Floats) {
+                stageNameToValue[val.stageName] = val.exportedValue;
+            }
+            foreach (var val in Bools) {
+                stageNameToValue[val.stageName] = val.value ? 1.0f : 0.0f;
+            }
+        }
+        Ints.Clear();
+        Bools.Clear();
+        Floats.Clear();
+        StageParamterToBuiltin.Clear();
+        IntToIndex.Clear();
+        FloatToIndex.Clear();
+        BoolToIndex.Clear();
+        playableParamterFloats.Clear();
+        playableParamterIds.Clear();
+        playableParamterInts.Clear();
+        playableParamterBools.Clear();
+        return stageNameToValue;
+    }
+    void LateRefreshExpressionParameters(Dictionary<string, float> stageNameToValue) {
+        HashSet<string> usedparams = new HashSet<string>(BUILTIN_PARAMETERS);
+        int i = 0;
+        if (stageParameters != null)
+        {
+            int stageId = 0;
+            foreach (var stageParam in stageParameters.parameters)
+            {
+                stageId++; // one-indexed
+                if (stageParam.name == null || stageParam.name.Length == 0) {
+                    continue;
+                }
+                string stageName = stageParam.name + (stageParam.saved ? " (saved/SYNCED)" : " (SYNCED)"); //"Stage" + stageId;
+                float lastDefault = 0.0f;
+                if (AvatarSyncSource == this) {
+                    lastDefault = (stageParam.saved && KeepSavedParametersOnReset && stageNameToValue.ContainsKey(stageName) ? stageNameToValue[stageName] : stageParam.defaultValue);
+                }
+                StageParamterToBuiltin.Add(stageName, stageParam.name);
+                if ((int)stageParam.valueType == 0)
+                {
+                    IntParam param = new IntParam();
+                    param.stageName = stageName;
+                    param.synced = true;
+                    param.name = stageParam.name;
+                    param.value = (int)lastDefault;
+                    param.lastValue = 0;
+                    IntToIndex[param.name] = Ints.Count;
+                    Ints.Add(param);
+                }
+                else if ((int)stageParam.valueType == 1)
+                {
+                    FloatParam param = new FloatParam();
+                    param.stageName = stageName;
+                    param.synced = true;
+                    param.name = stageParam.name;
+                    param.value = lastDefault;
+                    param.exportedValue = lastDefault;
+                    param.lastValue = 0;
+                    FloatToIndex[param.name] = Floats.Count;
+                    Floats.Add(param);
+                }
+                else if ((int)stageParam.valueType == 2)
+                {
+                    BoolParam param = new BoolParam();
+                    param.stageName = stageName;
+                    param.synced = true;
+                    param.name = stageParam.name;
+                    param.value = lastDefault != 0.0;
+                    param.lastValue = false;
+                    param.hasBool = new bool[playables.Count];
+                    param.hasTrigger = new bool[playables.Count];
+                    BoolToIndex[param.name] = Bools.Count;
+                    Bools.Add(param);
+                }
+                usedparams.Add(stageParam.name);
+                i++;
+            }
+        } else {
+            IntParam param = new IntParam();
+            param.stageName = "VRCEmote";
+            param.synced = true;
+            param.name = "VRCEmote";
+            Ints.Add(param);
+            usedparams.Add("VRCEmote");
+            FloatParam fparam = new FloatParam();
+            fparam.stageName = "VRCFaceBlendH";
+            fparam.synced = true;
+            fparam.name = "VRCFaceBlendH";
+            Floats.Add(fparam);
+            usedparams.Add("VRCFaceBlendH");
+            fparam = new FloatParam();
+            fparam.stageName = "VRCFaceBlendV";
+            fparam.synced = true;
+            fparam.name = "VRCFaceBlendV";
+            Floats.Add(fparam);
+            usedparams.Add("VRCFaceBlendV");
+        }
+
+        //playableParamterIds
+        int whichcontroller = 0;
+        playableParamterIds.Clear();
+        foreach (AnimatorControllerPlayable playable in playables) {
+            Dictionary<string, int> parameterIndices = new Dictionary<string, int>();
+            playableParamterInts.Add(new Dictionary<int, int>());
+            playableParamterFloats.Add(new Dictionary<int, float>());
+            playableParamterBools.Add(new Dictionary<int, bool>());
+            // Debug.Log("SETUP index " + whichcontroller + " len " + playables.Count);
+            playableParamterIds.Add(parameterIndices);
+            int pcnt = playable.IsValid() ? playable.GetParameterCount() : 0;
+            for (i = 0; i < pcnt; i++) {
+                AnimatorControllerParameter aparam = playable.GetParameter(i);
+                string actualName;
+                if (!StageParamterToBuiltin.TryGetValue(aparam.name, out actualName)) {
+                    actualName = aparam.name;
+                }
+                parameterIndices[actualName] = aparam.nameHash;
+                if (usedparams.Contains(actualName)) {
+                    if (BoolToIndex.ContainsKey(aparam.name) && aparam.type == AnimatorControllerParameterType.Bool) {
+                        Bools[BoolToIndex[aparam.name]].hasBool[whichcontroller] = true;
+                    }
+                    if (BoolToIndex.ContainsKey(aparam.name) && aparam.type == AnimatorControllerParameterType.Trigger) {
+                        Bools[BoolToIndex[aparam.name]].hasTrigger[whichcontroller] = true;
+                    }
+                    continue;
+                }
+                if (aparam.type == AnimatorControllerParameterType.Int) {
+                    IntParam param = new IntParam();
+                    param.stageName = aparam.name + " (local)";
+                    param.synced = false;
+                    param.name = aparam.name;
+                    param.value = aparam.defaultInt;
+                    param.lastValue = param.value;
+                    IntToIndex[param.name] = Ints.Count;
+                    Ints.Add(param);
+                    usedparams.Add(aparam.name);
+                } else if (aparam.type == AnimatorControllerParameterType.Float) {
+                    FloatParam param = new FloatParam();
+                    param.stageName = aparam.name + " (local)";
+                    param.synced = false;
+                    param.name = aparam.name;
+                    param.value = aparam.defaultFloat;
+                    param.exportedValue = aparam.defaultFloat;
+                    param.lastValue = param.value;
+                    FloatToIndex[param.name] = Floats.Count;
+                    Floats.Add(param);
+                    usedparams.Add(aparam.name);
+                } else if (aparam.type == AnimatorControllerParameterType.Trigger || aparam.type == AnimatorControllerParameterType.Bool) {
+                    BoolParam param = new BoolParam();
+                    param.stageName = aparam.name + " (local)";
+                    param.synced = false;
+                    param.name = aparam.name;
+                    param.value = aparam.defaultBool;
+                    param.lastValue = param.value;
+                    param.hasBool = new bool[playables.Count];
+                    param.hasTrigger = new bool[playables.Count];
+                    param.hasBool[whichcontroller] = aparam.type == AnimatorControllerParameterType.Bool;
+                    param.hasTrigger[whichcontroller] = aparam.type == AnimatorControllerParameterType.Trigger;
+                    BoolToIndex[param.name] = Bools.Count;
+                    Bools.Add(param);
+                    usedparams.Add(aparam.name);
+                }
+            }
+            whichcontroller++;
+        }
+    }
+
+    void CreateAv3MenuComponent() {
+        System.Type gestureManagerMenu = System.Type.GetType("GestureManagerAv3Menu");
+        if (gestureManagerMenu != null) {
+            foreach (var comp in avadesc.gameObject.GetComponents(gestureManagerMenu)) {
+                UnityEngine.Object.Destroy(comp);
+            }
+        }
+        foreach (var comp in avadesc.gameObject.GetComponents<LyumaAv3Menu>()) {
+            UnityEngine.Object.Destroy(comp);
+        }
+        LyumaAv3Menu mainMenu;
+        if (gestureManagerMenu != null) {
+            mainMenu = (LyumaAv3Menu)avadesc.gameObject.AddComponent(gestureManagerMenu);
+            mainMenu.useLegacyMenu = legacyMenuGUI;
+        } else {
+            mainMenu = avadesc.gameObject.AddComponent<LyumaAv3Menu>();
+        }
+        mainMenu.Runtime = this;
+        mainMenu.RootMenu = avadesc.expressionsMenu;
+    }
+
+
+    private bool isResetting;
+    private bool isResettingHold;
+    private bool isResettingSel;
+    void LateUpdate() {
+        if (ResetAndHold || (emulator != null && (!emulator.enabled || !emulator.gameObject.activeInHierarchy))) {
+            return;
+        }
+        if (IsMirrorClone || IsShadowClone) {
+            // Experimental. Attempt to reproduce the 1-frame desync in some cases between normal and mirror copy.
+            NormalUpdate();
+        }
+        if(animator != null && this == AvatarSyncSource && !IsMirrorClone && !IsShadowClone) {
+            if (MirrorClone != null) {
+                MirrorClone.gameObject.SetActive(true);
+                MirrorClone.transform.localRotation = transform.localRotation;
+                MirrorClone.transform.localScale = transform.localScale;
+                MirrorClone.transform.position = transform.position + (DebugOffsetMirrorClone ? new Vector3(0.0f, 1.3f * avadesc.ViewPosition.y, 0.0f) : Vector3.zero);
+            }
+            if (ShadowClone != null) {
+                ShadowClone.gameObject.SetActive(true);
+                ShadowClone.transform.localRotation = transform.localRotation;
+                ShadowClone.transform.localScale = transform.localScale;
+                ShadowClone.transform.position = transform.position;
+            }
+            foreach (Transform[] allXTransforms in new Transform[][]{allMirrorTransforms, allShadowTransforms}) {
+                if (allXTransforms != null) {
+                    Transform head = animator.GetBoneTransform(HumanBodyBones.Head);
+                    for(int i = 0; i < allTransforms.Length && i < allXTransforms.Length; i++) {
+                        if (allXTransforms[i] == null || allTransforms[i] == this.transform) {
+                            continue;
+                        }
+                        MeshRenderer mr = allTransforms[i].GetComponent<MeshRenderer>();
+                        MeshRenderer xmr = allXTransforms[i].GetComponent<MeshRenderer>();
+                        if (mr != null && xmr != null) {
+                            for (int mri = 0; mri < mr.sharedMaterials.Length && mri < xmr.sharedMaterials.Length; mri++) {
+                                xmr.sharedMaterials[mri] = mr.sharedMaterials[mri];
+                            }
+                        }
+                        allXTransforms[i].localPosition = allTransforms[i].localPosition;
+                        allXTransforms[i].localRotation = allTransforms[i].localRotation;
+                        if(allTransforms[i] == head && EnableHeadScaling) {
+                            allXTransforms[i].localScale = new Vector3(1.0f, 1.0f, 1.0f);
+                        } else {
+                            allXTransforms[i].localScale = allTransforms[i].localScale;
+                        }
+                        bool theirs = allTransforms[i].gameObject.activeSelf;
+                        if (allXTransforms[i].gameObject.activeSelf != theirs) {
+                            allXTransforms[i].gameObject.SetActive(theirs);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    void FixedUpdate() {
+        if (Jump && !WasJump && Grounded) {
+            JumpingVelocity = new Vector3(0.0f, JumpPower, 0.0f);
+            JumpingHeight += JumpingVelocity;
+            Grounded = false;
+        }
+        WasJump = Jump;
+        if (JumpingHeight != Vector3.zero) {
+            JumpingHeight += JumpingVelocity;
+            JumpingVelocity += Physics.gravity * Time.fixedDeltaTime;
+            if (JumpingHeight.y <= 0.0f) {
+                JumpingHeight = Vector3.zero;
+                JumpingVelocity = Vector3.zero;
+                Grounded = true;
+                Jump = false;
+                WasJump = false;
+            }
+            Velocity.y = JumpingVelocity.y;
+ 
+        }
+    }
+
+    private bool broadcastStartNextFrame;
+    void OnEnable() {
+        if (emulator != null && emulator.WorkaroundPlayModeScriptCompile) {
+            ApplyOnEnableWorkaroundDelegate();
+        }
+        if (attachedAnimators == null && AvatarSyncSource != null) {
+            broadcastStartNextFrame = true;
+        }
+    }
+
+    void Update() {
+        if (broadcastStartNextFrame) {
+            Debug.Log("BROADCASTING START!");
+            broadcastStartNextFrame = false;
+            BroadcastMessage("Start");
+        }
+        if (emulator != null && (!emulator.enabled || !emulator.gameObject.activeInHierarchy)) {
+            return;
+        }
+        if (!IsMirrorClone && !IsShadowClone) {
+            NormalUpdate();
+        }
+    }
+
+    // Update is called once per frame
+    void NormalUpdate()
+    {
+        if (OSCConfigurationFile.OSCAvatarID == null) {
+            OSCConfigurationFile.OSCAvatarID = A3EOSCConfiguration.AVTR_EMULATOR_PREFIX + "Default";
+        }
+        if ((OSCConfigurationFile.UseRealPipelineIdJSONFile && OSCConfigurationFile.OSCAvatarID.StartsWith(A3EOSCConfiguration.AVTR_EMULATOR_PREFIX)) ||
+                (!OSCConfigurationFile.UseRealPipelineIdJSONFile && !OSCConfigurationFile.OSCAvatarID.StartsWith(A3EOSCConfiguration.AVTR_EMULATOR_PREFIX))) {
+            var pipelineManager = avadesc.GetComponent<VRC.Core.PipelineManager>();
+            string avatarid = pipelineManager != null ? pipelineManager.blueprintId : null;
+            OSCConfigurationFile.EnsureOSCJSONConfig(avadesc.expressionParameters, avatarid, this.gameObject.name);
+        }
+        if (OSCConfigurationFile.SaveOSCConfig) {
+            OSCConfigurationFile.SaveOSCConfig = false;
+            A3EOSCConfiguration.WriteJSON(OSCConfigurationFile.OSCFilePath, OSCConfigurationFile.OSCJsonConfig);
+        }
+        if (OSCConfigurationFile.LoadOSCConfig) {
+            OSCConfigurationFile.LoadOSCConfig = false;
+            OSCConfigurationFile.OSCJsonConfig = A3EOSCConfiguration.ReadJSON(OSCConfigurationFile.OSCFilePath);
+        }
+        if (OSCConfigurationFile.GenerateOSCConfig) {
+            OSCConfigurationFile.GenerateOSCConfig = false;
+            OSCConfigurationFile.OSCJsonConfig = A3EOSCConfiguration.GenerateOuterJSON(avadesc.expressionParameters, OSCConfigurationFile.OSCAvatarID, this.gameObject.name);
+        }
+        if (lastLegacyMenuGUI != legacyMenuGUI && AvatarSyncSource == this) {
+            lastLegacyMenuGUI = legacyMenuGUI;
+            foreach (var av3MenuComponent in GetComponents<LyumaAv3Menu>()) {
+                av3MenuComponent.useLegacyMenu = legacyMenuGUI;
+            }
+        }
+        if (isResettingSel) {
+            isResettingSel = false;
+            if (updateSelectionDelegate != null && AvatarSyncSource == this) {
+                updateSelectionDelegate(this.gameObject);
+                PrevAnimatorToViewLiteParamsShow0 = (char)126;
+            }
+        }
+        if (isResettingHold && (!ResetAvatar || !ResetAndHold)) {
+            ResetAndHold = ResetAvatar = false;
+            isResettingSel = true;
+            if (updateSelectionDelegate != null && AvatarSyncSource == this) {
+                updateSelectionDelegate(this.emulator != null ? this.emulator.gameObject : null);
+                PrevAnimatorToViewLiteParamsShow0 = (char)126;
+            }
+        }
+        if (ResetAvatar && ResetAndHold) {
+            return;
+        }
+        if (ResetAndHold && !ResetAvatar && !isResetting) {
+            ResetAvatar = true;
+            isResettingHold = true;
+        }
+        if (isResetting && !ResetAndHold) {
+            if (attachedAnimators == null) {
+                if (AvatarSyncSource == this) {
+                    AvatarSyncSource = null;
+                }
+                Awake();
+                isResetting = false;
+                isResettingHold = false;
+                return;
+            } else {
+                InitializeAnimator();
+            }
+            isResetting = false;
+            isResettingHold = false;
+        }
+        if (PrevAnimatorToDebug != (char)(int)DebugDuplicateAnimator || ResetAvatar || attachedAnimators == null) {
+            actionIndex = fxIndex = gestureIndex = additiveIndex = sittingIndex = ikposeIndex = tposeIndex = -1;
+            altActionIndex = altFXIndex = altGestureIndex = altAdditiveIndex = -1;
+            // animator.runtimeAnimatorController = null;
+            if (playableGraph.IsValid()) {
+                playableGraph.Destroy();
+            }
+            if (animator.playableGraph.IsValid()) {
+                animator.playableGraph.Destroy();
+            }
+            animator.Update(0);
+            animator.Rebind();
+            animator.Update(0);
+            animator.StopPlayback();
+            GameObject.DestroyImmediate(animator);
+            // animator.runtimeAnimatorController = EmptyController;
+            if (updateSelectionDelegate != null && AvatarSyncSource == this) {
+                updateSelectionDelegate(this.emulator != null ? this.emulator.gameObject : null);
+            }
+            isResetting = true;
+            isResettingSel = true;
+            return;
+        }
+        if (PrevAnimatorToViewLiteParamsShow0 == (char)127) {
+            updateSelectionDelegate(this);
+            ViewAnimatorOnlyNoParams = (VRCAvatarDescriptor.AnimLayerType)(int)126;
+            PrevAnimatorToViewLiteParamsShow0 = (char)(int)ViewAnimatorOnlyNoParams;
+        }
+        if ((char)(int)ViewAnimatorOnlyNoParams != PrevAnimatorToViewLiteParamsShow0) {
+            PrevAnimatorToViewLiteParamsShow0 = (char)127;
+            RuntimeAnimatorController rac = null;
+            allControllers.TryGetValue(ViewAnimatorOnlyNoParams, out rac);
+            updateSelectionDelegate(rac == null ? (UnityEngine.Object)this.emulator : (UnityEngine.Object)rac);
+        }
+        if (RefreshExpressionParams) {
+            RefreshExpressionParams = false;
+            Dictionary<string, float> stageNameToValue = EarlyRefreshExpressionParameters();
+            LateRefreshExpressionParameters(stageNameToValue);
+        }
+        if(this == AvatarSyncSource && !IsMirrorClone && !IsShadowClone) {
+            Transform head = animator.GetBoneTransform(HumanBodyBones.Head);
+            if (head != null) {
+                head.localScale = EnableHeadScaling ? new Vector3(0.0001f, 0.0001f, 0.0001f) : new Vector3(1.0f, 1.0f, 1.0f); // head bone is set to 0.0001 locally (not multiplied
+            }
+        }
+        if (DisableMirrorAndShadowClones && (MirrorClone != null || ShadowClone != null)) {
+            allMirrorTransforms = null;
+            allShadowTransforms = null;
+            GameObject.Destroy(MirrorClone.gameObject);
+            MirrorClone = null;
+            GameObject.Destroy(ShadowClone.gameObject);
+            ShadowClone = null;
+        }
+        if (!DisableMirrorAndShadowClones && MirrorClone == null && ShadowClone == null) {
+            CreateMirrorClone();
+            CreateShadowClone();
+        }
+        if (emulator != null) {
+            if (LastViewMirrorReflection != ViewMirrorReflection) {
+                emulator.ViewMirrorReflection = ViewMirrorReflection;
+            } else {
+                ViewMirrorReflection = emulator.ViewMirrorReflection;
+            }
+            LastViewMirrorReflection = ViewMirrorReflection;
+            if (LastViewBothRealAndMirror != ViewBothRealAndMirror) {
+                emulator.ViewBothRealAndMirror = ViewBothRealAndMirror;
+            } else {
+                ViewBothRealAndMirror = emulator.ViewBothRealAndMirror;
+            }
+            LastViewBothRealAndMirror = ViewBothRealAndMirror;
+            var osc = emulator.GetComponent<LyumaAv3Osc>();
+            if (OSCController != null && EnableAvatarOSC && (!osc.openSocket || osc.avatarDescriptor != avadesc)) {
+                EnableAvatarOSC = false;
+                OSCController = null;
+            }
+            if (OSCController != null && !EnableAvatarOSC) {
+                osc.openSocket = false;
+                OSCController = null;
+            }
+            if (OSCController == null && EnableAvatarOSC) {
+                osc = emulator.gameObject.GetOrAddComponent<LyumaAv3Osc>();
+                osc.openSocket = true;
+                osc.avatarDescriptor = avadesc;
+                osc.enabled = true;
+                OSCController = osc;
+                // updateSelectionDelegate(osc.gameObject);
+            }
+        }
+
+        if (CreateNonLocalClone) {
+            CreateNonLocalClone = false;
+            GameObject go = GameObject.Instantiate(OriginalSourceClone.gameObject);
+            go.hideFlags = 0;
+            AvatarSyncSource.CloneCount++;
+            go.name = go.name.Substring(0, go.name.Length - 7) + " (Non-Local " + AvatarSyncSource.CloneCount + ")";
+            go.transform.position = go.transform.position + AvatarSyncSource.CloneCount * new Vector3(0.4f, 0.0f, 0.4f);
+            go.SetActive(true);
+        }
+        if (IsMirrorClone || IsShadowClone) {
+            NonLocalSyncInterval = 0.0f;
+        } else {
+            NonLocalSyncInterval = AvatarSyncSource.NonLocalSyncInterval;
+        }
+        if (nextUpdateTime == 0.0f) {
+            nextUpdateTime = Time.time + NonLocalSyncInterval;
+        }
+        bool ShouldSyncThisFrame = (AvatarSyncSource != this && (Time.time >= nextUpdateTime || NonLocalSyncInterval <= 0.0f));
+        if (AvatarSyncSource != this) {
+            IKSyncRadialMenu = AvatarSyncSource.IKSyncRadialMenu;
+            LyumaAv3Menu[] menus = AvatarSyncSource.GetComponents<LyumaAv3Menu>();
+            for (int i = 0; i < Ints.Count; i++) {
+                if (StageParamterToBuiltin.ContainsKey(Ints[i].stageName)) {
+                    // Simulate IK sync of open gesture parameter.
+                    if (ShouldSyncThisFrame || (IKSyncRadialMenu && menus.Length >= 1 && menus[0].IsControlIKSynced(Ints[i].name))
+                            || (IKSyncRadialMenu && menus.Length >= 2 && menus[1].IsControlIKSynced(Ints[i].name))) {
+                        Ints[i].value = ClampByte(AvatarSyncSource.Ints[i].value);
+                    }
+                }
+            }
+            for (int i = 0; i < Floats.Count; i++) {
+                if (StageParamterToBuiltin.ContainsKey(Floats[i].stageName)) {
+                    // Simulate IK sync of open gesture parameter.
+                    if (ShouldSyncThisFrame || (IKSyncRadialMenu && menus.Length >= 1 && menus[0].IsControlIKSynced(Floats[i].name))
+                            || (IKSyncRadialMenu && menus.Length >= 2 && menus[1].IsControlIKSynced(Floats[i].name))) {
+                        Floats[i].exportedValue = ClampAndQuantizeFloat(AvatarSyncSource.Floats[i].exportedValue);
+                        Floats[i].value = Floats[i].exportedValue;
+                    }
+                }
+            }
+            for (int i = 0; i < Bools.Count; i++) {
+                if (StageParamterToBuiltin.ContainsKey(Bools[i].stageName)) {
+                    if (ShouldSyncThisFrame) {
+                        Bools[i].value = AvatarSyncSource.Bools[i].value;
+                    }
+                }
+            }
+            if (ShouldSyncThisFrame) {
+                nextUpdateTime = Time.time + NonLocalSyncInterval;
+            }
+        }
+        if (AvatarSyncSource != this) {
+            // Simulate more continuous "IK sync" of these parameters.
+            VisemeInt = VisemeIdx = AvatarSyncSource.VisemeInt;
+            Viseme = (VisemeIndex)VisemeInt;
+            GestureLeft = AvatarSyncSource.GestureLeft;
+            GestureLeftIdx = AvatarSyncSource.GestureLeftIdx;
+            GestureLeftIdxInt = AvatarSyncSource.GestureLeftIdxInt;
+            GestureLeftWeight = AvatarSyncSource.GestureLeftWeight;
+            GestureRight = AvatarSyncSource.GestureRight;
+            GestureRightIdx = AvatarSyncSource.GestureRightIdx;
+            GestureRightIdxInt = AvatarSyncSource.GestureRightIdxInt;
+            GestureRightWeight = AvatarSyncSource.GestureRightWeight;
+            Velocity = AvatarSyncSource.Velocity;
+            AngularY = AvatarSyncSource.AngularY;
+            Upright = AvatarSyncSource.Upright;
+            Grounded = AvatarSyncSource.Grounded;
+            Seated = AvatarSyncSource.Seated;
+            AFK = AvatarSyncSource.AFK;
+            TrackingType = AvatarSyncSource.TrackingType;
+            TrackingTypeIdx = AvatarSyncSource.TrackingTypeIdx;
+            TrackingTypeIdxInt = AvatarSyncSource.TrackingTypeIdxInt;
+            VRMode = AvatarSyncSource.VRMode;
+            MuteSelf = AvatarSyncSource.MuteSelf;
+            InStation = AvatarSyncSource.InStation;
+        }
+        for (int i = 0; i < Floats.Count; i++) {
+            if (Floats[i].expressionValue != Floats[i].lastExpressionValue_) {
+                Floats[i].exportedValue = Floats[i].expressionValue;
+                Floats[i].lastExpressionValue_ = Floats[i].expressionValue;
+            }
+            if (StageParamterToBuiltin.ContainsKey(Floats[i].stageName)) {
+                if (locally8bitQuantizedFloats) {
+                    Floats[i].exportedValue = ClampAndQuantizeFloat(Floats[i].exportedValue);
+                } else {
+                    Floats[i].exportedValue = ClampFloatOnly(Floats[i].exportedValue);
+                }
+                Floats[i].value = Floats[i].exportedValue;
+            }
+        }
+        for (int i = 0; i < Ints.Count; i++) {
+            if (StageParamterToBuiltin.ContainsKey(Ints[i].stageName)) {
+                Ints[i].value = ClampByte(Ints[i].value);
+            }
+        }
+        if (Seated != PrevSeated && sittingIndex >= 0 && playableBlendingStates[sittingIndex] != null)
+        {
+            playableBlendingStates[sittingIndex].StartBlend(playableMixer.GetInputWeight(sittingIndex + 1), Seated ? 1f : 0f, 0.25f);
+            PrevSeated = Seated;
+        }
+        if (TPoseCalibration != PrevTPoseCalibration && tposeIndex >= 0 && playableBlendingStates[tposeIndex] != null) {
+            playableBlendingStates[tposeIndex].StartBlend(playableMixer.GetInputWeight(tposeIndex + 1), TPoseCalibration ? 1f : 0f, 0.0f);
+            PrevTPoseCalibration = TPoseCalibration;
+        }
+        if (IKPoseCalibration != PrevIKPoseCalibration && ikposeIndex >= 0 && playableBlendingStates[ikposeIndex] != null) {
+            playableBlendingStates[ikposeIndex].StartBlend(playableMixer.GetInputWeight(ikposeIndex + 1), IKPoseCalibration ? 1f : 0f, 0.0f);
+            PrevIKPoseCalibration = IKPoseCalibration;
+        }
+        if (VisemeIdx != VisemeInt) {
+            VisemeInt = VisemeIdx;
+            Viseme = (VisemeIndex)VisemeInt;
+        }
+        if ((int)Viseme != VisemeInt) {
+            VisemeInt = (int)Viseme;
+            VisemeIdx = VisemeInt;
+        }
+        if (GestureLeftWeight != OldGestureLeftWeight) {
+            OldGestureLeftWeight = GestureLeftWeight;
+            if (GestureLeftWeight < 0.01f) {
+                GestureLeftIdx = 0;
+            }
+            if (GestureLeftWeight > 0.01f && (GestureLeftIdx == 0 || GestureLeftWeight < 0.99f)) {
+                GestureLeftIdx = 1;
+            } 
+        }
+        if (GestureRightWeight != OldGestureRightWeight) {
+            OldGestureRightWeight = GestureRightWeight;
+            if (GestureRightWeight < 0.01f) {
+                GestureRightIdx = 0;
+            }
+            if (GestureRightWeight > 0.01f && (GestureRightIdx == 0 || GestureRightWeight < 0.99f)) {
+                GestureRightIdx = 1;
+            } 
+        }
+        if (GestureLeftIdx != GestureLeftIdxInt) {
+            GestureLeft = (GestureIndex)GestureLeftIdx;
+            GestureLeftIdx = (int)GestureLeft;
+            GestureLeftIdxInt = (char)GestureLeftIdx;
+        }
+        if ((int)GestureLeft != (int)GestureLeftIdxInt) {
+            GestureLeftIdx = (int)GestureLeft;
+            GestureLeftIdxInt = (char)GestureLeftIdx;
+        }
+        if (GestureRightIdx != GestureRightIdxInt) {
+            GestureRight = (GestureIndex)GestureRightIdx;
+            GestureRightIdx = (int)GestureRight;
+            GestureRightIdxInt = (char)GestureRightIdx;
+        }
+        if ((int)GestureRight != (int)GestureRightIdxInt) {
+            GestureRightIdx = (int)GestureRight;
+            GestureRightIdxInt = (char)GestureRightIdx;
+        }
+        if (GestureLeft == GestureIndex.Neutral) {
+            GestureLeftWeight = 0;
+        } else if (GestureLeft != GestureIndex.Fist) {
+            GestureLeftWeight = 1;
+        }
+        if (GestureRight == GestureIndex.Neutral) {
+            GestureRightWeight = 0;
+        } else if (GestureRight != GestureIndex.Fist) {
+            GestureRightWeight = 1;
+        }
+        if (TrackingTypeIdx != TrackingTypeIdxInt) {
+            TrackingType = (TrackingTypeIndex)TrackingTypeIdx;
+            TrackingTypeIdx = (int)TrackingType;
+            TrackingTypeIdxInt = (char)TrackingTypeIdx;
+        }
+        if ((int)TrackingType != TrackingTypeIdxInt) {
+            TrackingTypeIdx = (int)TrackingType;
+            TrackingTypeIdxInt = (char)TrackingTypeIdx;
+        }
+        IsLocal = AvatarSyncSource == this;
+
+        int whichcontroller;
+        whichcontroller = 0;
+        foreach (AnimatorControllerPlayable playable in playables)
+        {
+            if (!playable.IsValid()) {
+                whichcontroller++;
+                continue;
+            }
+            // Debug.Log("Index " + whichcontroller + " len " + playables.Count);
+            Dictionary<string, int> parameterIndices = playableParamterIds[whichcontroller];
+            int paramid;
+            foreach (FloatParam param in Floats)
+            {
+                if (parameterIndices.TryGetValue(param.name, out paramid))
+                {
+                    if (param.value != param.lastValue) {
+                        playable.SetFloat(paramid, param.value);
+                    }
+                }
+            }
+            foreach (IntParam param in Ints)
+            {
+                if (parameterIndices.TryGetValue(param.name, out paramid))
+                {
+                    if (param.value != param.lastValue) {
+                        playable.SetInteger(paramid, param.value);
+                    }
+                }
+            }
+            foreach (BoolParam param in Bools)
+            {
+                if (parameterIndices.TryGetValue(param.name, out paramid))
+                {
+                    if (param.value != param.lastValue) {
+                        playable.SetBool(paramid, param.value); // also sets triggers.
+                        // if (param.value) {
+                        //     playable.SetTrigger(paramid);
+                        // }
+                    }
+                }
+            }
+            whichcontroller++;
+        }
+        foreach (FloatParam param in Floats) {
+            param.lastValue = param.value;
+        }
+        foreach (IntParam param in Ints) {
+            param.lastValue = param.value;
+        }
+        foreach (BoolParam param in Bools) {
+            param.lastValue = param.value;
+        }
+
+        whichcontroller = 0;
+        foreach (AnimatorControllerPlayable playable in playables)
+        {
+            if (!playable.IsValid()) {
+                whichcontroller++;
+                continue;
+            }
+            // Debug.Log("Index " + whichcontroller + " len " + playables.Count);
+            Dictionary<string, int> parameterIndices = playableParamterIds[whichcontroller];
+            Dictionary<int, int> paramterInts = playableParamterInts[whichcontroller];
+            Dictionary<int, float> paramterFloats = playableParamterFloats[whichcontroller];
+            Dictionary<int, bool> paramterBools = playableParamterBools[whichcontroller];
+            int paramid;
+            float fparam;
+            int iparam;
+            bool bparam;
+            foreach (FloatParam param in Floats)
+            {
+                if (parameterIndices.TryGetValue(param.name, out paramid))
+                {
+                    if (paramterFloats.TryGetValue(paramid, out fparam)) {
+                        if (fparam != playable.GetFloat(paramid)) {
+                            param.value = param.lastValue = playable.GetFloat(paramid);
+                            if (!playable.IsParameterControlledByCurve(paramid)) {
+                                param.exportedValue = param.value;
+                            }
+                        }
+                    }
+                    paramterFloats[paramid] = param.value;
+                }
+            }
+            foreach (IntParam param in Ints)
+            {
+                if (parameterIndices.TryGetValue(param.name, out paramid))
+                {
+                    if (paramterInts.TryGetValue(paramid, out iparam)) {
+                        if (iparam != playable.GetInteger(paramid)) {
+                            param.value = param.lastValue = playable.GetInteger(paramid);
+                        }
+                    }
+                    paramterInts[paramid] = param.value;
+                }
+            }
+            foreach (BoolParam param in Bools)
+            {
+                if (param.hasBool[whichcontroller] && parameterIndices.TryGetValue(param.name, out paramid))
+                {
+                    if (paramterBools.TryGetValue(paramid, out bparam)) {
+                        if (bparam != (playable.GetBool(paramid))) {
+                            param.value = param.lastValue = playable.GetBool(paramid);
+                        }
+                    }
+                    paramterBools[paramid] = param.value;
+                }
+            }
+            if (parameterIndices.TryGetValue("Viseme", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != playable.GetInteger(paramid)) {
+                    VisemeInt = VisemeIdx = playable.GetInteger(paramid);
+                    Viseme = (VisemeIndex)VisemeInt;
+                }
+                playable.SetInteger(paramid, VisemeInt);
+                paramterInts[paramid] = VisemeInt;
+            }
+            if (parameterIndices.TryGetValue("GestureLeft", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != playable.GetInteger(paramid)) {
+                    GestureLeftIdx = playable.GetInteger(paramid);
+                    GestureLeftIdxInt = (char)GestureLeftIdx;
+                    GestureLeft = (GestureIndex)GestureLeftIdx;
+                }
+                playable.SetInteger(paramid, (int)GestureLeft);
+                paramterInts[paramid] = (int)GestureLeft;
+            }
+            if (parameterIndices.TryGetValue("GestureLeftWeight", out paramid))
+            {
+                if (paramterFloats.TryGetValue(paramid, out fparam) && fparam != playable.GetFloat(paramid)) {
+                    GestureLeftWeight = playable.GetFloat(paramid);
+                }
+                playable.SetFloat(paramid, GestureLeftWeight);
+                paramterFloats[paramid] = GestureLeftWeight;
+            }
+            if (parameterIndices.TryGetValue("GestureRight", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != playable.GetInteger(paramid)) {
+                    GestureRightIdx = playable.GetInteger(paramid);
+                    GestureRightIdxInt = (char)GestureRightIdx;
+                    GestureRight = (GestureIndex)GestureRightIdx;
+                }
+                playable.SetInteger(paramid, (int)GestureRight);
+                paramterInts[paramid] = (int)GestureRight;
+            }
+            if (parameterIndices.TryGetValue("GestureRightWeight", out paramid))
+            {
+                if (paramterFloats.TryGetValue(paramid, out fparam) && fparam != playable.GetFloat(paramid)) {
+                    GestureRightWeight = playable.GetFloat(paramid);
+                }
+                playable.SetFloat(paramid, GestureRightWeight);
+                paramterFloats[paramid] = GestureRightWeight;
+            }
+            if (parameterIndices.TryGetValue("VelocityX", out paramid))
+            {
+                if (paramterFloats.TryGetValue(paramid, out fparam) && fparam != playable.GetFloat(paramid)) {
+                    Velocity.x = playable.GetFloat(paramid);
+                }
+                playable.SetFloat(paramid, Velocity.x);
+                paramterFloats[paramid] = Velocity.x;
+            }
+            if (parameterIndices.TryGetValue("VelocityY", out paramid))
+            {
+                if (paramterFloats.TryGetValue(paramid, out fparam) && fparam != playable.GetFloat(paramid)) {
+                    Velocity.y = playable.GetFloat(paramid);
+                }
+                playable.SetFloat(paramid, Velocity.y);
+                paramterFloats[paramid] = Velocity.y;
+            }
+            if (parameterIndices.TryGetValue("VelocityZ", out paramid))
+            {
+                if (paramterFloats.TryGetValue(paramid, out fparam) && fparam != playable.GetFloat(paramid)) {
+                    Velocity.z = playable.GetFloat(paramid);
+                }
+                playable.SetFloat(paramid, Velocity.z);
+                paramterFloats[paramid] = Velocity.z;
+            }
+            if (parameterIndices.TryGetValue("AngularY", out paramid))
+            {
+                if (paramterFloats.TryGetValue(paramid, out fparam) && fparam != playable.GetFloat(paramid)) {
+                    AngularY = playable.GetFloat(paramid);
+                }
+                playable.SetFloat(paramid, AngularY);
+                paramterFloats[paramid] = AngularY;
+            }
+            if (parameterIndices.TryGetValue("Upright", out paramid))
+            {
+                if (paramterFloats.TryGetValue(paramid, out fparam) && fparam != playable.GetFloat(paramid)) {
+                    Upright = playable.GetFloat(paramid);
+                }
+                playable.SetFloat(paramid, Upright);
+                paramterFloats[paramid] = Upright;
+            }
+            if (parameterIndices.TryGetValue("IsLocal", out paramid))
+            {
+                playable.SetBool(paramid, IsLocal);
+            }
+            if (parameterIndices.TryGetValue("Grounded", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != (playable.GetBool(paramid) ? 1 : 0)) {
+                    Grounded = playable.GetBool(paramid);
+                }
+                playable.SetBool(paramid, Grounded);
+                paramterInts[paramid] = Grounded ? 1 : 0;
+            }
+            if (parameterIndices.TryGetValue("Seated", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != (playable.GetBool(paramid) ? 1 : 0)) {
+                    Seated = playable.GetBool(paramid);
+                }
+                playable.SetBool(paramid, Seated);
+                paramterInts[paramid] = Seated ? 1 : 0;
+            }
+            if (parameterIndices.TryGetValue("AFK", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != (playable.GetBool(paramid) ? 1 : 0)) {
+                    AFK = playable.GetBool(paramid);
+                }
+                playable.SetBool(paramid, AFK);
+                paramterInts[paramid] = AFK ? 1 : 0;
+            }
+            if (parameterIndices.TryGetValue("TrackingType", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != playable.GetInteger(paramid)) {
+                    TrackingTypeIdx = playable.GetInteger(paramid);
+                    TrackingTypeIdxInt = (char)TrackingTypeIdx;
+                    TrackingType = (TrackingTypeIndex)TrackingTypeIdx;
+                }
+                playable.SetInteger(paramid, (int)TrackingType);
+                paramterInts[paramid] = (int)TrackingType;
+            }
+            if (parameterIndices.TryGetValue("VRMode", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != playable.GetInteger(paramid)) {
+                    VRMode = playable.GetInteger(paramid) != 0;
+                }
+                playable.SetInteger(paramid, VRMode ? 1 : 0);
+                paramterInts[paramid] = VRMode ? 1 : 0;
+            }
+            if (parameterIndices.TryGetValue("MuteSelf", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != (playable.GetBool(paramid) ? 1 : 0)) {
+                    MuteSelf = playable.GetBool(paramid);
+                }
+                playable.SetBool(paramid, MuteSelf);
+                paramterInts[paramid] = MuteSelf ? 1 : 0;
+            }
+            if (parameterIndices.TryGetValue("InStation", out paramid))
+            {
+                if (paramterInts.TryGetValue(paramid, out iparam) && iparam != (playable.GetBool(paramid) ? 1 : 0))
+                {
+                    InStation = playable.GetBool(paramid);
+                }
+                playable.SetBool(paramid, InStation);
+                paramterInts[paramid] = InStation ? 1 : 0;
+            }
+            if (parameterIndices.TryGetValue("AvatarVersion", out paramid)) {
+                playable.SetInteger(paramid, AvatarVersion);
+            }
+            whichcontroller++;
+        }
+
+        if (((emulator != null && !emulator.DisableAvatarDynamicsIntegration)
+            || (AvatarSyncSource?.emulator != null && !AvatarSyncSource.emulator.DisableAvatarDynamicsIntegration)) &&
+            !IsMirrorClone && !IsShadowClone)
+        {
+            assignContactParameters(avadesc.gameObject.GetComponentsInChildren<VRCContactReceiver>());
+            assignPhysBoneParameters(avadesc.gameObject.GetComponentsInChildren<VRCPhysBone>());
+        }
+
+        for (int i = 0; i < playableBlendingStates.Count; i++) {
+            var pbs = playableBlendingStates[i];
+            if (pbs == null) {
+                continue;
+            }
+            if (pbs.blending) {
+                float newWeight = pbs.UpdateBlending();
+                playableMixer.SetInputWeight(i + 1, newWeight);
+                // Debug.Log("Whole playable " + i + " is blending to " + newWeight);
+            }
+            for (int j = 0; j < pbs.layerBlends.Count; j++) {
+                if (pbs.layerBlends[j].blending) {
+                    float newWeight = pbs.layerBlends[j].UpdateBlending();
+                    playables[i].SetLayerWeight(j, newWeight);
+                    // Debug.Log("Playable " + i + " layer " + j + " is blending to " + newWeight);
+                }
+            }
+        }
+        if (avadesc.lipSync == VRC.SDKBase.VRC_AvatarDescriptor.LipSyncStyle.JawFlapBone && avadesc.lipSyncJawBone != null) {
+            if (Viseme == VisemeIndex.sil) {
+                avadesc.lipSyncJawBone.transform.rotation = avadesc.lipSyncJawClosed;
+            } else {
+                avadesc.lipSyncJawBone.transform.rotation = avadesc.lipSyncJawOpen;
+            }
+        } else if (avadesc.lipSync == VRC.SDKBase.VRC_AvatarDescriptor.LipSyncStyle.JawFlapBlendShape && avadesc.VisemeSkinnedMesh != null && mouthOpenBlendShapeIdx != -1) {
+            if (Viseme == VisemeIndex.sil) {
+                avadesc.VisemeSkinnedMesh.SetBlendShapeWeight(mouthOpenBlendShapeIdx, 0.0f);
+            } else {
+                avadesc.VisemeSkinnedMesh.SetBlendShapeWeight(mouthOpenBlendShapeIdx, 100.0f);
+            }
+        } else if (avadesc.lipSync == VRC.SDKBase.VRC_AvatarDescriptor.LipSyncStyle.VisemeBlendShape && avadesc.VisemeSkinnedMesh != null) {
+            for (int i = 0; i < visemeBlendShapeIdxs.Length; i++) {
+                if (visemeBlendShapeIdxs[i] != -1) {
+                    avadesc.VisemeSkinnedMesh.SetBlendShapeWeight(visemeBlendShapeIdxs[i], (i == VisemeIdx ? 100.0f : 0.0f));
+                }
+            }
+        }
+    }
+
+    float getObjectFloat(object o) {
+        switch (o) {
+            // case bool b:
+            //     return b ? 1.0f : 0.0f;
+            // case int i:
+            //     return (float)i;
+            // case long l:
+            //     return (float)l;
+            case float f:
+                return f;
+            // case double d:
+            //     return (float)d;
+        }
+        return 0.0f;
+    }
+    int getObjectInt(object o) {
+        switch (o) {
+            // case bool b:
+            //     return b ? 1 : 0;
+            case int i:
+                return i;
+            // case long l:
+            //     return (int)l;
+            // case float f:
+            //     return (int)f;
+            // case double d:
+            //     return (int)d;
+        }
+        return 0;
+    }
+    bool isObjectTrue(object o) {
+        switch (o) {
+            case bool b:
+                return b;
+            case int i:
+                return i == 1;
+            // case long l:
+            //     return l == 1;
+            // case float f:
+            //     return f == 1.0f;
+            // case double d:
+            //     return d == 1.0;
+        }
+        return false;
+    }
+
+    public void GetOSCDataInto(List<A3ESimpleOSC.OSCMessage> messages) {
+        messages.Add(new A3ESimpleOSC.OSCMessage {
+            arguments = new object[1] {(object)OSCConfigurationFile.OSCAvatarID},
+            path="/avatar/change",
+            time = new Vector2Int(-1,-1),
+        });
+        if (OSCConfigurationFile.SendRecvAllParamsNotInJSON) {
+            foreach (var b in Bools) {
+                if (b.synced) {
+                    messages.Add(new A3ESimpleOSC.OSCMessage {
+                        arguments = new object[1] {(object)(int)((bool)b.value ? 1 : 0)},
+                        path = "/avatar/parameters/" + b.name,
+                        time = new Vector2Int(-1,-1),
+                    });
+                }
+            }
+            foreach (var i in Ints) {
+                if (i.synced) {
+                    messages.Add(new A3ESimpleOSC.OSCMessage {
+                        arguments = new object[1] {(object)(int)i.value},
+                        path = "/avatar/parameters/" + i.name,
+                        time = new Vector2Int(-1,-1),
+                    });
+                }
+            }
+            foreach (var f in Floats) {
+                if (f.synced) {
+                    messages.Add(new A3ESimpleOSC.OSCMessage {
+                        arguments = new object[1] {(object)(float)f.value},
+                        path = "/avatar/parameters/" + f.name,
+                        time = new Vector2Int(-1,-1),
+                    });
+                }
+            }
+        } else {
+            foreach (var prop in OSCConfigurationFile.OSCJsonConfig.parameters) {
+                if (prop.name != null && prop.name.Length > 0 && prop.output.address != null && prop.output.address.Length > 0) {
+                    string addr = prop.output.address;
+                    float outputf = 0.0f;
+                    string typ = "?";
+                    if (BoolToIndex.TryGetValue(prop.name, out var bidx)) {
+                        if (!Bools[bidx].synced) {
+                            continue;
+                        }
+                        outputf = Bools[bidx].value ? 1.0f : 0.0f;
+                        typ = "bool";
+                    } else if (IntToIndex.TryGetValue(prop.name, out var iidx)) {
+                        if (!Ints[iidx].synced) {
+                            continue;
+                        }
+                        outputf = (float)Ints[iidx].value;
+                        typ = "int";
+                    } else if (FloatToIndex.TryGetValue(prop.name, out var fidx)) {
+                        if (!Floats[fidx].synced) {
+                            continue;
+                        }
+                        outputf = Floats[fidx].value;
+                        typ = "float";
+                    } else {
+                        switch (prop.name) {
+                            case "VelocityZ":
+                                outputf = Velocity.z;
+                                break;
+                            case "VelocityY":
+                                outputf = Velocity.y;
+                                break;
+                            case "VelocityX":
+                                outputf = Velocity.x;
+                                break;
+                            case "InStation":
+                                outputf = InStation ? 1.0f : 0.0f;
+                                break;
+                            case "Seated":
+                                outputf = Seated ? 1.0f : 0.0f;
+                                break;
+                            case "AFK":
+                                outputf = AFK ? 1.0f : 0.0f;
+                                break;
+                            case "Upright":
+                                outputf = Upright;
+                                break;
+                            case "AngularY":
+                                outputf = AngularY;
+                                break;
+                            case "Grounded":
+                                outputf = Grounded ? 1.0f : 0.0f;
+                                break;
+                            case "MuteSelf":
+                                outputf = MuteSelf ? 1.0f : 0.0f;
+                                break;
+                            case "VRMode":
+                                outputf = VRMode ? 1.0f : 0.0f;
+                                break;
+                            case "TrackingType":
+                                outputf = TrackingTypeIdxInt;
+                                break;
+                            case "GestureRightWeight":
+                                outputf = GestureRightWeight;
+                                break;
+                            case "GestureRight":
+                                outputf = GestureRightIdxInt;
+                                break;
+                            case "GestureLeftWeight":
+                                outputf = GestureLeftWeight;
+                                break;
+                            case "GestureLeft":
+                                outputf = GestureLeftIdxInt;
+                                break;
+                            case "Voice":
+                                outputf = Voice;
+                                break;
+                            case "Viseme":
+                                outputf = VisemeInt;
+                                break;
+                            default:
+                                Debug.LogWarning("Unrecognized built in param");
+                                break;
+                        }
+                    }
+                    object output;
+                    switch (prop.output.type) {
+                        case "Float":
+                            output = (object)(float)outputf;
+                            break;
+                        case "Int":
+                            output = (object)(int)outputf;
+                            break;
+                        case "Bool":
+                            output = (object)(outputf != 0.0f);
+                            break;
+                        default:
+                            Debug.LogError("Unrecognized JSON type " + prop.input.type + " for address " + addr + " for output " + typ + " parameter " +
+                            prop.name + ". Should be \"Float\", \"Int\" or \"Bool\".");
+                            continue;
+                    }
+                    messages.Add(new A3ESimpleOSC.OSCMessage {
+                        arguments = new object[1] {(object)output},
+                        path = addr,
+                        time = new Vector2Int(-1,-1),
+                    });
+                }
+            }
+        }
+    }
+    public void processOSCInputMessage(string ParamName, object arg0) {
+        float argFloat = getObjectFloat(arg0);
+        int argInt = getObjectInt(arg0);
+        bool argBool = isObjectTrue(arg0);
+        switch (ParamName) {
+        case "Vertical":
+            Velocity.z = (3.0f + RunSpeed) * argFloat;
+            break;
+        case "Horizontal":
+            Velocity.x = (3.0f + RunSpeed) * (float)arg0;
+            break;
+        case "LookHorizontal":
+            AngularY = argFloat;
+            break;
+        case "UseAxisRight":
+        case "GrabAxisRight":
+        case "MoveHoldFB":
+        case "SpinHoldCwCcw":
+        case "SpinHoldUD":
+        case "SpinHoldLR":
+            break;
+        case "MoveForward":
+            Velocity.z = argBool ? 5.0f : 0.0f;
+            break;
+        case "MoveBackward":
+            Velocity.z = argBool ? -5.0f : 0.0f;
+            break;
+        case "MoveLeft":
+            Velocity.x = argBool ? -5.0f : 0.0f;
+            break;
+        case "MoveRight":
+            Velocity.x = argBool ? 5.0f : 0.0f;
+            break;
+        case "LookLeft":
+            AngularY = argBool ? -1.0f : 0.0f;
+            break;
+        case "LookRight":
+            AngularY = argBool ? 1.0f : 0.0f;
+            break;
+        case "Jump":
+            Jump = argBool;
+            break;
+        case "Run":
+            RunSpeed = argBool ? 3.0f : 0.0f;
+            break;
+        case "ComfortLeft":
+        case "ComfortRight":
+        case "DropRight":
+        case "UseRight":
+        case "GrabRight":
+        case "DropLeft":
+        case "UseLeft":
+        case "GrabLeft":
+        case "PanicButton":
+        case "QuickMenuToggleLeft":
+        case "QuickMenuToggleRight":
+            break;
+        case "Voice":
+            if (argBool && !MuteTogglerOn) {
+                MuteSelf = !MuteSelf;
+            }
+            MuteTogglerOn = argBool;
+            break;
+        default:
+            Debug.LogWarning("Unrecognized OSC input command " + ParamName);
+            break;
+        }
+    }
+    public void HandleOSCMessages(List<A3ESimpleOSC.OSCMessage> messages) {
+        var innerProperties = new Dictionary<string, A3EOSCConfiguration.InnerJson>();
+        foreach (var ij in OSCConfigurationFile.OSCJsonConfig.parameters) {
+            if (ij.input.address != null && ij.input.address.Length > 0) {
+                innerProperties[ij.input.address] = ij;
+            }
+        }
+        foreach (var msg in messages) {
+            string msgPath = msg.path;
+            object[] arguments = msg.arguments;
+            if (AvatarSyncSource != this || !IsLocal || IsMirrorClone || IsShadowClone) {
+                return;
+            }
+            float argFloat = getObjectFloat(arguments[0]);
+            int argInt = getObjectInt(arguments[0]);
+            bool argBool = isObjectTrue(arguments[0]);
+            if (msgPath.StartsWith("/input/")) {
+                string ParamName = msgPath.Split(new char[]{'/'}, 3)[2];
+                processOSCInputMessage(ParamName, arguments[0]);
+            } else {
+                string ParamName;
+                if (OSCConfigurationFile.SendRecvAllParamsNotInJSON) {
+                    ParamName = msgPath.Split(new char[]{'/'}, 4)[3];
+                } else if (innerProperties.ContainsKey(msgPath)) {
+                    ParamName = innerProperties[msgPath].name;
+                    if (innerProperties[msgPath].input.type == "Float") {
+                        if (arguments[0].GetType() != typeof(float)) {
+                            Debug.LogWarning("Address " + msgPath + " for parameter " + ParamName + " expected float in JSON but received " + arguments[0].GetType());
+                            continue;
+                        }
+                    } else if (innerProperties[msgPath].input.type == "Int" || innerProperties[msgPath].input.type == "Bool") {
+                        if (arguments[0].GetType() != typeof(int) && arguments[0].GetType() != typeof(bool)) {
+                            Debug.LogWarning("Address " + msgPath + " for parameter " + ParamName + " expected int/bool in JSON but received " + arguments[0].GetType());
+                            continue;
+                        }
+                    } else {
+                        Debug.LogError("Unrecognized JSON type " + innerProperties[msgPath].input.type + " for address " + msgPath + " for inupt parameter " +
+                                ParamName + " but received " + arguments[0].GetType() + ". Should be \"Float\", \"Int\" or \"Bool\".");
+                        continue;
+                    }
+                } else {
+                    Debug.LogWarning("Address " + msgPath + " not found for input in JSON.");
+                    continue;
+                }
+                if (OSCController != null && OSCController.debugPrintReceivedMessages) {
+                    Debug.Log("Recvd "+ParamName + ": " + msg);
+                }
+                if (arguments.Length > 0 && arguments[0].GetType() == typeof(bool)) {
+                    int idx;
+                    if (BoolToIndex.TryGetValue(ParamName, out idx)) {
+                        Bools[idx].value = (bool)(arguments[0]);
+                    }
+                    if (IntToIndex.TryGetValue(ParamName, out idx)) {
+                        Ints[idx].value = (int)(arguments[0]);
+                    }
+                }
+                if (arguments.Length > 0 && arguments[0].GetType() == typeof(int)) {
+                    int idx;
+                    if (BoolToIndex.TryGetValue(ParamName, out idx)) {
+                        Bools[idx].value = ((int)(arguments[0])) != 0;
+                    }
+                    if (IntToIndex.TryGetValue(ParamName, out idx)) {
+                        Ints[idx].value = (int)(arguments[0]);
+                    }
+                }
+                if (arguments.Length > 0 && arguments[0].GetType() == typeof(float)) {
+                    int idx;
+                    if (FloatToIndex.TryGetValue(ParamName, out idx)) {
+                        Floats[idx].value = (float)(arguments[0]);
+                        Floats[idx].exportedValue = Floats[idx].value;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Runtime.cs.meta b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Runtime.cs.meta
new file mode 100644
index 00000000..fe086a2b
--- /dev/null
+++ b/VRCSDK3Avatars/Assets/Resources/Lyuma/Av3Emulator/Scripts/LyumaAv3Runtime.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: da29383b5c207b04585f808c1caad277
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: