Add files using upload-large-folder tool

.gitattributes

@@ -739,3 +739,5 @@ benchmark/IOL/official_pdfs/2008/iol-2008-indiv-prob.bg.pdf filter=lfs diff=lfs
 benchmark/IOL/official_pdfs/2008/iol-2008-indiv-prob.pl.pdf filter=lfs diff=lfs merge=lfs -text
 benchmark/IOL/official_pdfs/2008/iol-2008-indiv-prob.ru.pdf filter=lfs diff=lfs merge=lfs -text
 benchmark/IOL/official_pdfs/2008/iol-2008-indiv-prob.sl.pdf filter=lfs diff=lfs merge=lfs -text
+benchmark/science_bowl/MS-Sample-Questions/Sample-Set-8/Round-6-A.pdf filter=lfs diff=lfs merge=lfs -text
+benchmark/science_bowl/MS-Sample-Questions/Sample-Set-2/sample_questions_r10.pdf filter=lfs diff=lfs merge=lfs -text

benchmark/IOAI/IOAI-2025/GAITE-Contest/Synthetic_Speech_Detector/training_set/bonafide/LA_E_6693511_bonafide.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92c270a306ad3d1fa4149454df8db7e47053ddc8663d1b4ffe7cbd6d7720b612
+size 49378

benchmark/IOAI/IOAI-2025/GAITE-Contest/Synthetic_Speech_Detector/training_set/bonafide/LA_E_6699186_bonafide.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71b8353165e956b86d71ae109089e6fdea45c5237aa2a16eb65967cc151c266a
+size 49378

benchmark/IOAI/IOAI-2025/GAITE-Contest/Synthetic_Speech_Detector/training_set/bonafide/LA_E_6813363_bonafide.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c51fde43b5b0851042a8bc85ce8a359eaabbc56c186ba0b87eb6b484e784744
+size 49378

benchmark/IOAI/IOAI-2025/GAITE-Contest/Synthetic_Speech_Detector/training_set/bonafide/LA_E_6813643_bonafide.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af35c029ba0f4b8ce15b59d282a7929035b016cc5e662d47d0b2da484528dfca
+size 49378

benchmark/IOAI/IOAI-2025/GAITE-Contest/Synthetic_Speech_Detector/training_set/spoof/LA_E_2458742_spoof_A13.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ad34195d2c8fbe0f81e92f22e6e3953337d4bcd5d71bb26f85568628b99ad6a
+size 49447

benchmark/IOAI/IOAI-2025/GAITE-Contest/Synthetic_Speech_Detector/training_set/spoof/LA_E_2501421_spoof_A10.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b3208cda03d97b910f3c60c2c5881c6394ab24e6119bdaec1bd29add2b4428b
+size 49447

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/DropdownOptionListDrawer.cs

@@ -0,0 +1,60 @@
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEditor;
+
+namespace TMPro.EditorUtilities
+{
+    [CustomPropertyDrawer(typeof(TMP_Dropdown.OptionDataList), true)]
+    class DropdownOptionListDrawer : PropertyDrawer
+    {
+        private ReorderableList m_ReorderableList;
+
+        private void Init(SerializedProperty property)
+        {
+            if (m_ReorderableList != null)
+                return;
+
+            SerializedProperty array = property.FindPropertyRelative("m_Options");
+
+            m_ReorderableList = new ReorderableList(property.serializedObject, array);
+            m_ReorderableList.drawElementCallback = DrawOptionData;
+            m_ReorderableList.drawHeaderCallback = DrawHeader;
+            m_ReorderableList.elementHeight += 16;
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            Init(property);
+
+            m_ReorderableList.DoList(position);
+        }
+
+        private void DrawHeader(Rect rect)
+        {
+            GUI.Label(rect, "Options");
+        }
+
+        private void DrawOptionData(Rect rect, int index, bool isActive, bool isFocused)
+        {
+            SerializedProperty itemData = m_ReorderableList.serializedProperty.GetArrayElementAtIndex(index);
+            SerializedProperty itemText = itemData.FindPropertyRelative("m_Text");
+            SerializedProperty itemImage = itemData.FindPropertyRelative("m_Image");
+
+            RectOffset offset = new RectOffset(0, 0, -1, -3);
+            rect = offset.Add(rect);
+            rect.height = EditorGUIUtility.singleLineHeight;
+
+            EditorGUI.PropertyField(rect, itemText, GUIContent.none);
+            rect.y += EditorGUIUtility.singleLineHeight;
+            EditorGUI.PropertyField(rect, itemImage, GUIContent.none);
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            Init(property);
+
+            return m_ReorderableList.GetHeight();
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/DropdownOptionListDrawer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9545c9eb3bf94265810463794fec8334
+timeCreated: 1464818008
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/GlyphInfoDrawer.cs

@@ -0,0 +1,61 @@
+/*
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+
+namespace TMPro.EditorUtilities
+{
+
+    [CustomPropertyDrawer(typeof(TMP_Glyph))]
+    public class GlyphInfoDrawer : PropertyDrawer
+    {
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            SerializedProperty prop_id = property.FindPropertyRelative("id");
+            SerializedProperty prop_x = property.FindPropertyRelative("x");
+            SerializedProperty prop_y = property.FindPropertyRelative("y");
+            SerializedProperty prop_width = property.FindPropertyRelative("width");
+            SerializedProperty prop_height = property.FindPropertyRelative("height");
+            SerializedProperty prop_xOffset = property.FindPropertyRelative("xOffset");
+            SerializedProperty prop_yOffset = property.FindPropertyRelative("yOffset");
+            SerializedProperty prop_xAdvance = property.FindPropertyRelative("xAdvance");
+            SerializedProperty prop_scale = property.FindPropertyRelative("scale");
+
+
+            // We get Rect since a valid position may not be provided by the caller.
+            Rect rect = GUILayoutUtility.GetRect(position.width, 48);
+            rect.y -= 15;
+
+            //GUI.enabled = false;
+            EditorGUIUtility.labelWidth = 40f;
+            EditorGUIUtility.fieldWidth = 45f;
+
+            bool prevGuiState = GUI.enabled;
+            GUI.enabled = true;
+            EditorGUI.LabelField(new Rect(rect.x + 5f, rect.y, 80f, 18), new GUIContent("Ascii: <color=#FFFF80>" + prop_id.intValue + "</color>"), TMP_UIStyleManager.label);
+            EditorGUI.LabelField(new Rect(rect.x + 90f, rect.y, 80f, 18), new GUIContent("Hex: <color=#FFFF80>" + prop_id.intValue.ToString("X") + "</color>"), TMP_UIStyleManager.label);
+            EditorGUI.LabelField(new Rect(rect.x + 170f, rect.y, 80, 18), "Char: [ <color=#FFFF80>" + (char)prop_id.intValue + "</color> ]", TMP_UIStyleManager.label);
+            GUI.enabled = prevGuiState;
+
+            EditorGUIUtility.labelWidth = 35f;
+            EditorGUIUtility.fieldWidth = 10f;
+
+            float width = (rect.width - 5f) / 4;
+            EditorGUI.PropertyField(new Rect(rect.x + 5f + width * 0, rect.y + 22, width - 5f, 18), prop_x, new GUIContent("X:"));
+            EditorGUI.PropertyField(new Rect(rect.x + 5f + width * 1, rect.y + 22, width - 5f, 18), prop_y, new GUIContent("Y:"));
+            EditorGUI.PropertyField(new Rect(rect.x + 5f + width * 2, rect.y + 22, width - 5f, 18), prop_width, new GUIContent("W:"));
+            EditorGUI.PropertyField(new Rect(rect.x + 5f + width * 3, rect.y + 22, width - 5f, 18), prop_height, new GUIContent("H:"));
+
+            //GUI.enabled = true;
+            EditorGUI.PropertyField(new Rect(rect.x + 5f + width * 0, rect.y + 44, width - 5f, 18), prop_xOffset, new GUIContent("OX:"));
+            EditorGUI.PropertyField(new Rect(rect.x + 5f + width * 1, rect.y + 44, width - 5f, 18), prop_yOffset, new GUIContent("OY:"));
+            //GUI.enabled = true;
+            EditorGUI.PropertyField(new Rect(rect.x + 5f + width * 2, rect.y + 44, width - 5f, 18), prop_xAdvance, new GUIContent("ADV:"));
+            EditorGUI.PropertyField(new Rect(rect.x + 5f + width * 3, rect.y + 44, width - 5f, 18), prop_scale, new GUIContent("SF:"));
+        }
+
+    }
+}
+*/

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/GlyphInfoDrawer.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 900f1a451c764dc3bdcc0de815a15935
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/GlyphMetricsPropertyDrawer.cs

@@ -0,0 +1,53 @@
+using UnityEngine;
+using UnityEngine.TextCore;
+using UnityEditor;
+using System.Collections;
+
+
+namespace TMPro.EditorUtilities
+{
+
+    [CustomPropertyDrawer(typeof(GlyphMetrics))]
+    public class GlyphMetricsPropertyDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            SerializedProperty prop_Width = property.FindPropertyRelative("m_Width");
+            SerializedProperty prop_Height = property.FindPropertyRelative("m_Height");
+            SerializedProperty prop_HoriBearingX = property.FindPropertyRelative("m_HorizontalBearingX");
+            SerializedProperty prop_HoriBearingY = property.FindPropertyRelative("m_HorizontalBearingY");
+            SerializedProperty prop_HoriAdvance = property.FindPropertyRelative("m_HorizontalAdvance");
+
+            // We get Rect since a valid position may not be provided by the caller.
+            Rect rect = new Rect(position.x, position.y, position.width, 49);
+
+            EditorGUI.LabelField(new Rect(rect.x, rect.y - 2.5f, rect.width, 18), new GUIContent("Glyph Metrics"));
+
+            EditorGUIUtility.labelWidth = 50f;
+            EditorGUIUtility.fieldWidth = 15f;
+
+            //GUI.enabled = false;
+            float width = (rect.width - 75f) / 2;
+            EditorGUI.PropertyField(new Rect(rect.x + width * 0, rect.y + 20, width - 5f, 18), prop_Width, new GUIContent("W:"));
+            EditorGUI.PropertyField(new Rect(rect.x + width * 1, rect.y + 20, width - 5f, 18), prop_Height, new GUIContent("H:"));
+
+            //GUI.enabled = true;
+
+            width = (rect.width - 75f) / 3;
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.PropertyField(new Rect(rect.x + width * 0, rect.y + 40, width - 5f, 18), prop_HoriBearingX, new GUIContent("BX:"));
+            EditorGUI.PropertyField(new Rect(rect.x + width * 1, rect.y + 40, width - 5f, 18), prop_HoriBearingY, new GUIContent("BY:"));
+            EditorGUI.PropertyField(new Rect(rect.x + width * 2, rect.y + 40, width - 5f, 18), prop_HoriAdvance, new GUIContent("AD:"));
+            if (EditorGUI.EndChangeCheck())
+            {
+
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return 65f;
+        }
+
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/GlyphMetricsPropertyDrawer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e3882522a08b6f5459b4dea6f8791278
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/GlyphRectPropertyDrawer.cs

@@ -0,0 +1,44 @@
+using UnityEngine;
+using UnityEngine.TextCore;
+using UnityEditor;
+using System.Collections;
+
+
+namespace TMPro.EditorUtilities
+{
+
+    [CustomPropertyDrawer(typeof(GlyphRect))]
+    public class GlyphRectPropertyDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            //EditorGUI.BeginProperty(position, label, property);
+
+            SerializedProperty prop_X = property.FindPropertyRelative("m_X");
+            SerializedProperty prop_Y = property.FindPropertyRelative("m_Y");
+            SerializedProperty prop_Width = property.FindPropertyRelative("m_Width");
+            SerializedProperty prop_Height = property.FindPropertyRelative("m_Height");
+
+            // We get Rect since a valid position may not be provided by the caller.
+            Rect rect = new Rect(position.x, position.y, position.width, 49);
+            EditorGUI.LabelField(new Rect(rect.x, rect.y - 2.5f, rect.width, 18), new GUIContent("Glyph Rect"));
+
+            EditorGUIUtility.labelWidth = 50f;
+            EditorGUIUtility.fieldWidth = 20f;
+
+            //GUI.enabled = false;
+            float width = (rect.width - 75f) / 4;
+            EditorGUI.PropertyField(new Rect(rect.x + width * 0, rect.y + 20, width - 5f, 18), prop_X, new GUIContent("X:"));
+            EditorGUI.PropertyField(new Rect(rect.x + width * 1, rect.y + 20, width - 5f, 18), prop_Y, new GUIContent("Y:"));
+            EditorGUI.PropertyField(new Rect(rect.x + width * 2, rect.y + 20, width - 5f, 18), prop_Width, new GUIContent("W:"));
+            EditorGUI.PropertyField(new Rect(rect.x + width * 3, rect.y + 20, width - 5f, 18), prop_Height, new GUIContent("H:"));
+
+            //EditorGUI.EndProperty();
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return 45f;
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/GlyphRectPropertyDrawer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8bc2b083b068f3546a9509c805e0541c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_BaseEditorPanel.cs

@@ -0,0 +1,1336 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace TMPro.EditorUtilities
+{
+    public abstract class TMP_BaseEditorPanel : Editor
+    {
+        //Labels and Tooltips
+        static readonly GUIContent k_RtlToggleLabel = new GUIContent("Enable RTL Editor", "Reverses text direction and allows right to left editing.");
+        //static readonly GUIContent k_MainSettingsLabel = new GUIContent("Main Settings");
+        static readonly GUIContent k_FontAssetLabel = new GUIContent("Font Asset", "The Font Asset containing the glyphs that can be rendered for this text.");
+        static readonly GUIContent k_MaterialPresetLabel = new GUIContent("Material Preset", "The material used for rendering. Only materials created from the Font Asset can be used.");
+        static readonly GUIContent k_StyleLabel = new GUIContent("Text Style", "The style from a style sheet to be applied to the text.");
+        static readonly GUIContent k_AutoSizeLabel = new GUIContent("Auto Size", "Auto sizes the text to fit the available space.");
+        static readonly GUIContent k_FontSizeLabel = new GUIContent("Font Size", "The size the text will be rendered at in points.");
+        static readonly GUIContent k_AutoSizeOptionsLabel = new GUIContent("Auto Size Options");
+        static readonly GUIContent k_MinLabel = new GUIContent("Min", "The minimum font size.");
+        static readonly GUIContent k_MaxLabel = new GUIContent("Max", "The maximum font size.");
+        static readonly GUIContent k_WdLabel = new GUIContent("WD%", "Compresses character width up to this value before reducing font size.");
+        static readonly GUIContent k_LineLabel = new GUIContent("Line", "Negative value only. Compresses line height down to this value before reducing font size.");
+        static readonly GUIContent k_FontStyleLabel = new GUIContent("Font Style", "Styles to apply to the text such as Bold or Italic.");
+
+        static readonly GUIContent k_BoldLabel = new GUIContent("B", "Bold");
+        static readonly GUIContent k_ItalicLabel = new GUIContent("I", "Italic");
+        static readonly GUIContent k_UnderlineLabel = new GUIContent("U", "Underline");
+        static readonly GUIContent k_StrikethroughLabel = new GUIContent("S", "Strikethrough");
+        static readonly GUIContent k_LowercaseLabel = new GUIContent("ab", "Lowercase");
+        static readonly GUIContent k_UppercaseLabel = new GUIContent("AB", "Uppercase");
+        static readonly GUIContent k_SmallcapsLabel = new GUIContent("SC", "Smallcaps");
+
+        static readonly GUIContent k_ColorModeLabel = new GUIContent("Color Mode", "The type of gradient to use.");
+        static readonly GUIContent k_BaseColorLabel = new GUIContent("Vertex Color", "The base color of the text vertices.");
+        static readonly GUIContent k_ColorPresetLabel = new GUIContent("Color Preset", "A Color Preset which override the local color settings.");
+        static readonly GUIContent k_ColorGradientLabel = new GUIContent("Color Gradient", "The gradient color applied over the Vertex Color. Can be locally set or driven by a Gradient Asset.");
+        static readonly GUIContent k_CorenerColorsLabel = new GUIContent("Colors", "The color composition of the gradient.");
+        static readonly GUIContent k_OverrideTagsLabel = new GUIContent("Override Tags", "Whether the color settings override the <color> tag.");
+
+        static readonly GUIContent k_SpacingOptionsLabel = new GUIContent("Spacing Options (em)", "Spacing adjustments between different elements of the text. Values are in font units where a value of 1 equals 1/100em.");
+        static readonly GUIContent k_CharacterSpacingLabel = new GUIContent("Character");
+        static readonly GUIContent k_WordSpacingLabel = new GUIContent("Word");
+        static readonly GUIContent k_LineSpacingLabel = new GUIContent("Line");
+        static readonly GUIContent k_ParagraphSpacingLabel = new GUIContent("Paragraph");
+
+        static readonly GUIContent k_AlignmentLabel = new GUIContent("Alignment", "Horizontal and vertical aligment of the text within its container.");
+        static readonly GUIContent k_WrapMixLabel = new GUIContent("Wrap Mix (W <-> C)", "How much to favor words versus characters when distributing the text.");
+
+        static readonly GUIContent k_WrappingLabel = new GUIContent("Wrapping", "Wraps text to the next line when reaching the edge of the container.");
+        static readonly GUIContent[] k_WrappingOptions = { new GUIContent("Disabled"), new GUIContent("Enabled") };
+        static readonly GUIContent k_OverflowLabel = new GUIContent("Overflow", "How to display text which goes past the edge of the container.");
+
+        static readonly GUIContent k_MarginsLabel = new GUIContent("Margins", "The space between the text and the edge of its container.");
+        static readonly GUIContent k_GeometrySortingLabel = new GUIContent("Geometry Sorting", "The order in which text geometry is sorted. Used to adjust the way overlapping characters are displayed.");
+        static readonly GUIContent k_IsTextObjectScaleStatic = new GUIContent("Is Scale Static", "Controls whether a text object will be excluded from the InteralUpdate callback to handle scale changes of the text object or its parent(s).");
+        static readonly GUIContent k_RichTextLabel = new GUIContent("Rich Text", "Enables the use of rich text tags such as <color> and <font>.");
+        static readonly GUIContent k_EscapeCharactersLabel = new GUIContent("Parse Escape Characters", "Whether to display strings such as \"\\n\" as is or replace them by the character they represent.");
+        static readonly GUIContent k_VisibleDescenderLabel = new GUIContent("Visible Descender", "Compute descender values from visible characters only. Used to adjust layout behavior when hiding and revealing characters dynamically.");
+        static readonly GUIContent k_SpriteAssetLabel = new GUIContent("Sprite Asset", "The Sprite Asset used when NOT specifically referencing one using <sprite=\"Sprite Asset Name\">.");
+        static readonly GUIContent k_StyleSheetAssetLabel = new GUIContent("Style Sheet Asset", "The Style Sheet Asset used by this text object.");
+
+        static readonly GUIContent k_HorizontalMappingLabel = new GUIContent("Horizontal Mapping", "Horizontal UV mapping when using a shader with a texture face option.");
+        static readonly GUIContent k_VerticalMappingLabel = new GUIContent("Vertical Mapping", "Vertical UV mapping when using a shader with a texture face option.");
+        static readonly GUIContent k_LineOffsetLabel = new GUIContent("Line Offset", "Adds an horizontal offset to each successive line. Used for slanted texturing.");
+
+        static readonly GUIContent k_KerningLabel = new GUIContent("Kerning", "Enables character specific spacing between pairs of characters.");
+        static readonly GUIContent k_PaddingLabel = new GUIContent("Extra Padding", "Adds some padding between the characters and the edge of the text mesh. Can reduce graphical errors when displaying small text.");
+
+        static readonly GUIContent k_LeftLabel = new GUIContent("Left");
+        static readonly GUIContent k_TopLabel = new GUIContent("Top");
+        static readonly GUIContent k_RightLabel = new GUIContent("Right");
+        static readonly GUIContent k_BottomLabel = new GUIContent("Bottom");
+
+        protected static readonly GUIContent k_ExtraSettingsLabel = new GUIContent("Extra Settings");
+        protected static string[] k_UiStateLabel = new string[] { "<i>(Click to collapse)</i> ", "<i>(Click to expand)</i> " };
+
+        static Dictionary<int, TMP_Style> k_AvailableStyles = new Dictionary<int, TMP_Style>();
+        protected Dictionary<int, int> m_TextStyleIndexLookup = new Dictionary<int, int>();
+
+        protected struct Foldout
+        {
+            // Track Inspector foldout panel states, globally.
+            public static bool extraSettings = false;
+            public static bool materialInspector = true;
+        }
+
+        protected static int s_EventId;
+
+        public int selAlignGridA;
+        public int selAlignGridB;
+
+        protected SerializedProperty m_TextProp;
+
+        protected SerializedProperty m_IsRightToLeftProp;
+        protected string m_RtlText;
+
+        protected SerializedProperty m_FontAssetProp;
+
+        protected SerializedProperty m_FontSharedMaterialProp;
+        protected Material[] m_MaterialPresets;
+        protected GUIContent[] m_MaterialPresetNames;
+        protected Dictionary<int, int> m_MaterialPresetIndexLookup = new Dictionary<int, int>();
+        protected int m_MaterialPresetSelectionIndex;
+        protected bool m_IsPresetListDirty;
+
+        protected List<TMP_Style> m_Styles = new List<TMP_Style>();
+        protected GUIContent[] m_StyleNames;
+        protected int m_StyleSelectionIndex;
+
+        protected SerializedProperty m_FontStyleProp;
+
+        protected SerializedProperty m_FontColorProp;
+        protected SerializedProperty m_EnableVertexGradientProp;
+        protected SerializedProperty m_FontColorGradientProp;
+        protected SerializedProperty m_FontColorGradientPresetProp;
+        protected SerializedProperty m_OverrideHtmlColorProp;
+
+        protected SerializedProperty m_FontSizeProp;
+        protected SerializedProperty m_FontSizeBaseProp;
+
+        protected SerializedProperty m_AutoSizingProp;
+        protected SerializedProperty m_FontSizeMinProp;
+        protected SerializedProperty m_FontSizeMaxProp;
+
+        protected SerializedProperty m_LineSpacingMaxProp;
+        protected SerializedProperty m_CharWidthMaxAdjProp;
+
+        protected SerializedProperty m_CharacterSpacingProp;
+        protected SerializedProperty m_WordSpacingProp;
+        protected SerializedProperty m_LineSpacingProp;
+        protected SerializedProperty m_ParagraphSpacingProp;
+
+        protected SerializedProperty m_TextAlignmentProp;
+
+        protected SerializedProperty m_HorizontalAlignmentProp;
+        protected SerializedProperty m_VerticalAlignmentProp;
+
+        protected SerializedProperty m_HorizontalMappingProp;
+        protected SerializedProperty m_VerticalMappingProp;
+        protected SerializedProperty m_UvLineOffsetProp;
+
+        protected SerializedProperty m_EnableWordWrappingProp;
+        protected SerializedProperty m_WordWrappingRatiosProp;
+        protected SerializedProperty m_TextOverflowModeProp;
+        protected SerializedProperty m_PageToDisplayProp;
+        protected SerializedProperty m_LinkedTextComponentProp;
+        protected SerializedProperty m_ParentLinkedTextComponentProp;
+
+        protected SerializedProperty m_EnableKerningProp;
+
+        protected SerializedProperty m_IsRichTextProp;
+
+        protected SerializedProperty m_HasFontAssetChangedProp;
+
+        protected SerializedProperty m_EnableExtraPaddingProp;
+        protected SerializedProperty m_CheckPaddingRequiredProp;
+        protected SerializedProperty m_EnableEscapeCharacterParsingProp;
+        protected SerializedProperty m_UseMaxVisibleDescenderProp;
+        protected SerializedProperty m_GeometrySortingOrderProp;
+        protected SerializedProperty m_IsTextObjectScaleStaticProp;
+
+        protected SerializedProperty m_SpriteAssetProp;
+
+        protected SerializedProperty m_StyleSheetAssetProp;
+        protected SerializedProperty m_TextStyleHashCodeProp;
+
+        protected SerializedProperty m_MarginProp;
+
+        protected SerializedProperty m_ColorModeProp;
+
+        protected bool m_HavePropertiesChanged;
+
+        protected TMP_Text m_TextComponent;
+        protected TMP_Text m_PreviousLinkedTextComponent;
+        protected RectTransform m_RectTransform;
+
+        protected Material m_TargetMaterial;
+
+        protected Vector3[] m_RectCorners = new Vector3[4];
+        protected Vector3[] m_HandlePoints = new Vector3[4];
+
+        protected virtual void OnEnable()
+        {
+            m_TextProp = serializedObject.FindProperty("m_text");
+            m_IsRightToLeftProp = serializedObject.FindProperty("m_isRightToLeft");
+            m_FontAssetProp = serializedObject.FindProperty("m_fontAsset");
+            m_FontSharedMaterialProp = serializedObject.FindProperty("m_sharedMaterial");
+
+            m_FontStyleProp = serializedObject.FindProperty("m_fontStyle");
+
+            m_FontSizeProp = serializedObject.FindProperty("m_fontSize");
+            m_FontSizeBaseProp = serializedObject.FindProperty("m_fontSizeBase");
+
+            m_AutoSizingProp = serializedObject.FindProperty("m_enableAutoSizing");
+            m_FontSizeMinProp = serializedObject.FindProperty("m_fontSizeMin");
+            m_FontSizeMaxProp = serializedObject.FindProperty("m_fontSizeMax");
+
+            m_LineSpacingMaxProp = serializedObject.FindProperty("m_lineSpacingMax");
+            m_CharWidthMaxAdjProp = serializedObject.FindProperty("m_charWidthMaxAdj");
+
+            // Colors & Gradient
+            m_FontColorProp = serializedObject.FindProperty("m_fontColor");
+            m_EnableVertexGradientProp = serializedObject.FindProperty("m_enableVertexGradient");
+            m_FontColorGradientProp = serializedObject.FindProperty("m_fontColorGradient");
+            m_FontColorGradientPresetProp = serializedObject.FindProperty("m_fontColorGradientPreset");
+            m_OverrideHtmlColorProp = serializedObject.FindProperty("m_overrideHtmlColors");
+
+            m_CharacterSpacingProp = serializedObject.FindProperty("m_characterSpacing");
+            m_WordSpacingProp = serializedObject.FindProperty("m_wordSpacing");
+            m_LineSpacingProp = serializedObject.FindProperty("m_lineSpacing");
+            m_ParagraphSpacingProp = serializedObject.FindProperty("m_paragraphSpacing");
+
+            m_TextAlignmentProp = serializedObject.FindProperty("m_textAlignment");
+            m_HorizontalAlignmentProp = serializedObject.FindProperty("m_HorizontalAlignment");
+            m_VerticalAlignmentProp = serializedObject.FindProperty("m_VerticalAlignment");
+
+            m_HorizontalMappingProp = serializedObject.FindProperty("m_horizontalMapping");
+            m_VerticalMappingProp = serializedObject.FindProperty("m_verticalMapping");
+            m_UvLineOffsetProp = serializedObject.FindProperty("m_uvLineOffset");
+
+            m_EnableWordWrappingProp = serializedObject.FindProperty("m_enableWordWrapping");
+            m_WordWrappingRatiosProp = serializedObject.FindProperty("m_wordWrappingRatios");
+            m_TextOverflowModeProp = serializedObject.FindProperty("m_overflowMode");
+            m_PageToDisplayProp = serializedObject.FindProperty("m_pageToDisplay");
+            m_LinkedTextComponentProp = serializedObject.FindProperty("m_linkedTextComponent");
+            m_ParentLinkedTextComponentProp = serializedObject.FindProperty("parentLinkedComponent");
+
+            m_EnableKerningProp = serializedObject.FindProperty("m_enableKerning");
+
+            m_EnableExtraPaddingProp = serializedObject.FindProperty("m_enableExtraPadding");
+            m_IsRichTextProp = serializedObject.FindProperty("m_isRichText");
+            m_CheckPaddingRequiredProp = serializedObject.FindProperty("checkPaddingRequired");
+            m_EnableEscapeCharacterParsingProp = serializedObject.FindProperty("m_parseCtrlCharacters");
+            m_UseMaxVisibleDescenderProp = serializedObject.FindProperty("m_useMaxVisibleDescender");
+
+            m_GeometrySortingOrderProp = serializedObject.FindProperty("m_geometrySortingOrder");
+            m_IsTextObjectScaleStaticProp = serializedObject.FindProperty("m_IsTextObjectScaleStatic");
+
+            m_SpriteAssetProp = serializedObject.FindProperty("m_spriteAsset");
+
+            m_StyleSheetAssetProp = serializedObject.FindProperty("m_StyleSheet");
+            m_TextStyleHashCodeProp = serializedObject.FindProperty("m_TextStyleHashCode");
+
+            m_MarginProp = serializedObject.FindProperty("m_margin");
+
+            m_HasFontAssetChangedProp = serializedObject.FindProperty("m_hasFontAssetChanged");
+
+            m_ColorModeProp = serializedObject.FindProperty("m_colorMode");
+
+            m_TextComponent = (TMP_Text)target;
+            m_RectTransform = m_TextComponent.rectTransform;
+
+            // Restore Previous Linked Text Component
+            m_PreviousLinkedTextComponent = m_TextComponent.linkedTextComponent;
+
+            // Create new Material Editor if one does not exists
+            m_TargetMaterial = m_TextComponent.fontSharedMaterial;
+
+            // Set material inspector visibility
+            if (m_TargetMaterial != null)
+                UnityEditorInternal.InternalEditorUtility.SetIsInspectorExpanded(m_TargetMaterial, Foldout.materialInspector);
+
+            // Find all Material Presets matching the current Font Asset Material
+            m_MaterialPresetNames = GetMaterialPresets();
+
+            // Get Styles from Style Sheet
+            if (!m_TextComponent.m_isWaitingOnResourceLoad)
+                m_StyleNames = GetStyleNames();
+
+            // Register to receive events when style sheets are modified.
+            TMPro_EventManager.TEXT_STYLE_PROPERTY_EVENT.Add(ON_TEXT_STYLE_CHANGED);
+
+            // Initialize the Event Listener for Undo Events.
+            Undo.undoRedoPerformed += OnUndoRedo;
+        }
+
+        protected virtual void OnDisable()
+        {
+            // Set material inspector visibility
+            if (m_TargetMaterial != null)
+                Foldout.materialInspector = UnityEditorInternal.InternalEditorUtility.GetIsInspectorExpanded(m_TargetMaterial);
+
+            if (Undo.undoRedoPerformed != null)
+                Undo.undoRedoPerformed -= OnUndoRedo;
+
+            // Unregister from style sheet related events.
+            TMPro_EventManager.TEXT_STYLE_PROPERTY_EVENT.Remove(ON_TEXT_STYLE_CHANGED);
+        }
+
+        // Event received when Text Styles are changed.
+        void ON_TEXT_STYLE_CHANGED(bool isChanged)
+        {
+            m_StyleNames = GetStyleNames();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            // Make sure Multi selection only includes TMP Text objects.
+            if (IsMixSelectionTypes()) return;
+
+            serializedObject.Update();
+
+            DrawTextInput();
+
+            DrawMainSettings();
+
+            DrawExtraSettings();
+
+            EditorGUILayout.Space();
+
+            if (serializedObject.ApplyModifiedProperties() || m_HavePropertiesChanged)
+            {
+                m_TextComponent.havePropertiesChanged = true;
+                m_HavePropertiesChanged = false;
+                EditorUtility.SetDirty(target);
+            }
+        }
+
+        public void OnSceneGUI()
+        {
+            if (IsMixSelectionTypes()) return;
+
+            // Margin Frame & Handles
+            m_RectTransform.GetWorldCorners(m_RectCorners);
+            Vector4 marginOffset = m_TextComponent.margin;
+            Vector3 lossyScale = m_RectTransform.lossyScale;
+
+            m_HandlePoints[0] = m_RectCorners[0] + m_RectTransform.TransformDirection(new Vector3(marginOffset.x * lossyScale.x, marginOffset.w * lossyScale.y, 0));
+            m_HandlePoints[1] = m_RectCorners[1] + m_RectTransform.TransformDirection(new Vector3(marginOffset.x * lossyScale.x, -marginOffset.y * lossyScale.y, 0));
+            m_HandlePoints[2] = m_RectCorners[2] + m_RectTransform.TransformDirection(new Vector3(-marginOffset.z * lossyScale.x, -marginOffset.y * lossyScale.y, 0));
+            m_HandlePoints[3] = m_RectCorners[3] + m_RectTransform.TransformDirection(new Vector3(-marginOffset.z * lossyScale.x, marginOffset.w * lossyScale.y, 0));
+
+            Handles.DrawSolidRectangleWithOutline(m_HandlePoints, new Color32(255, 255, 255, 0), new Color32(255, 255, 0, 255));
+
+            // Draw & process FreeMoveHandles
+
+            // LEFT HANDLE
+            Vector3 oldLeft = (m_HandlePoints[0] + m_HandlePoints[1]) * 0.5f;
+            Vector3 newLeft = Handles.FreeMoveHandle(oldLeft, Quaternion.identity, HandleUtility.GetHandleSize(m_RectTransform.position) * 0.05f, Vector3.zero, Handles.DotHandleCap);
+            bool hasChanged = false;
+            if (oldLeft != newLeft)
+            {
+                float delta = oldLeft.x - newLeft.x;
+                marginOffset.x += -delta / lossyScale.x;
+                //Debug.Log("Left Margin H0:" + handlePoints[0] + "  H1:" + handlePoints[1]);
+                hasChanged = true;
+            }
+
+            // TOP HANDLE
+            Vector3 oldTop = (m_HandlePoints[1] + m_HandlePoints[2]) * 0.5f;
+            Vector3 newTop = Handles.FreeMoveHandle(oldTop, Quaternion.identity, HandleUtility.GetHandleSize(m_RectTransform.position) * 0.05f, Vector3.zero, Handles.DotHandleCap);
+            if (oldTop != newTop)
+            {
+                float delta = oldTop.y - newTop.y;
+                marginOffset.y += delta / lossyScale.y;
+                //Debug.Log("Top Margin H1:" + handlePoints[1] + "  H2:" + handlePoints[2]);
+                hasChanged = true;
+            }
+
+            // RIGHT HANDLE
+            Vector3 oldRight = (m_HandlePoints[2] + m_HandlePoints[3]) * 0.5f;
+            Vector3 newRight = Handles.FreeMoveHandle(oldRight, Quaternion.identity, HandleUtility.GetHandleSize(m_RectTransform.position) * 0.05f, Vector3.zero, Handles.DotHandleCap);
+            if (oldRight != newRight)
+            {
+                float delta = oldRight.x - newRight.x;
+                marginOffset.z += delta / lossyScale.x;
+                hasChanged = true;
+                //Debug.Log("Right Margin H2:" + handlePoints[2] + "  H3:" + handlePoints[3]);
+            }
+
+            // BOTTOM HANDLE
+            Vector3 oldBottom = (m_HandlePoints[3] + m_HandlePoints[0]) * 0.5f;
+            Vector3 newBottom = Handles.FreeMoveHandle(oldBottom, Quaternion.identity, HandleUtility.GetHandleSize(m_RectTransform.position) * 0.05f, Vector3.zero, Handles.DotHandleCap);
+            if (oldBottom != newBottom)
+            {
+                float delta = oldBottom.y - newBottom.y;
+                marginOffset.w += -delta / lossyScale.y;
+                hasChanged = true;
+                //Debug.Log("Bottom Margin H0:" + handlePoints[0] + "  H3:" + handlePoints[3]);
+            }
+
+            if (hasChanged)
+            {
+                Undo.RecordObjects(new Object[] {m_RectTransform, m_TextComponent }, "Margin Changes");
+                m_TextComponent.margin = marginOffset;
+                EditorUtility.SetDirty(target);
+            }
+        }
+
+        protected void DrawTextInput()
+        {
+            EditorGUILayout.Space();
+
+            Rect rect = EditorGUILayout.GetControlRect(false, 22);
+            GUI.Label(rect, new GUIContent("<b>Text Input</b>"), TMP_UIStyleManager.sectionHeader);
+
+            EditorGUI.indentLevel = 0;
+
+            // If the text component is linked, disable the text input box.
+            if (m_ParentLinkedTextComponentProp.objectReferenceValue != null)
+            {
+                EditorGUILayout.HelpBox("The Text Input Box is disabled due to this text component being linked to another.", MessageType.Info);
+            }
+            else
+            {
+                // Display RTL Toggle
+                float labelWidth = EditorGUIUtility.labelWidth;
+                EditorGUIUtility.labelWidth = 110f;
+
+                m_IsRightToLeftProp.boolValue = EditorGUI.Toggle(new Rect(rect.width - 120, rect.y + 3, 130, 20), k_RtlToggleLabel, m_IsRightToLeftProp.boolValue);
+
+                EditorGUIUtility.labelWidth = labelWidth;
+
+                EditorGUI.BeginChangeCheck();
+                EditorGUILayout.PropertyField(m_TextProp, GUIContent.none);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    m_TextComponent.m_inputSource = TMP_Text.TextInputSources.Text;
+                    m_TextComponent.m_isInputParsingRequired = true;
+                    m_HavePropertiesChanged = true;
+                }
+
+                if (m_IsRightToLeftProp.boolValue)
+                {
+                    // Copy source text to RTL string
+                    m_RtlText = string.Empty;
+                    string sourceText = m_TextProp.stringValue;
+
+                    // Reverse Text displayed in Text Input Box
+                    for (int i = 0; i < sourceText.Length; i++)
+                        m_RtlText += sourceText[sourceText.Length - i - 1];
+
+                    GUILayout.Label("RTL Text Input");
+
+                    EditorGUI.BeginChangeCheck();
+                    m_RtlText = EditorGUILayout.TextArea(m_RtlText, TMP_UIStyleManager.wrappingTextArea, GUILayout.Height(EditorGUI.GetPropertyHeight(m_TextProp) - EditorGUIUtility.singleLineHeight), GUILayout.ExpandWidth(true));
+
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        // Convert RTL input
+                        sourceText = string.Empty;
+
+                        // Reverse Text displayed in Text Input Box
+                        for (int i = 0; i < m_RtlText.Length; i++)
+                            sourceText += m_RtlText[m_RtlText.Length - i - 1];
+
+                        m_TextProp.stringValue = sourceText;
+                    }
+                }
+
+                // TEXT STYLE
+                if (m_StyleNames != null)
+                {
+                    rect = EditorGUILayout.GetControlRect(false, 17);
+
+                    m_TextStyleIndexLookup.TryGetValue(m_TextStyleHashCodeProp.intValue, out m_StyleSelectionIndex);
+
+                    EditorGUI.BeginChangeCheck();
+                    m_StyleSelectionIndex = EditorGUI.Popup(rect, k_StyleLabel, m_StyleSelectionIndex, m_StyleNames);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_TextStyleHashCodeProp.intValue = m_Styles[m_StyleSelectionIndex].hashCode;
+                        m_TextComponent.m_TextStyle = m_Styles[m_StyleSelectionIndex];
+                        m_HavePropertiesChanged = true;
+                    }
+                }
+            }
+        }
+
+        protected void DrawMainSettings()
+        {
+            // MAIN SETTINGS SECTION
+            GUILayout.Label(new GUIContent("<b>Main Settings</b>"), TMP_UIStyleManager.sectionHeader);
+
+            //EditorGUI.indentLevel += 1;
+
+            DrawFont();
+
+            DrawColor();
+
+            DrawSpacing();
+
+            DrawAlignment();
+
+            DrawWrappingOverflow();
+
+            DrawTextureMapping();
+
+            //EditorGUI.indentLevel -= 1;
+        }
+
+        void DrawFont()
+        {
+            bool isFontAssetDirty = false;
+
+            // FONT ASSET
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_FontAssetProp, k_FontAssetLabel);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_HavePropertiesChanged = true;
+                m_HasFontAssetChangedProp.boolValue = true;
+
+                // Get new Material Presets for the new font asset
+                m_MaterialPresetNames = GetMaterialPresets();
+                m_MaterialPresetSelectionIndex = 0;
+
+                isFontAssetDirty = true;
+            }
+
+            Rect rect;
+
+            // MATERIAL PRESET
+            if (m_MaterialPresetNames != null && !isFontAssetDirty )
+            {
+                EditorGUI.BeginChangeCheck();
+                rect = EditorGUILayout.GetControlRect(false, 17);
+
+                float oldHeight = EditorStyles.popup.fixedHeight;
+                EditorStyles.popup.fixedHeight = rect.height;
+
+                int oldSize = EditorStyles.popup.fontSize;
+                EditorStyles.popup.fontSize = 11;
+
+                if (m_FontSharedMaterialProp.objectReferenceValue != null)
+                    m_MaterialPresetIndexLookup.TryGetValue(m_FontSharedMaterialProp.objectReferenceValue.GetInstanceID(), out m_MaterialPresetSelectionIndex);
+
+                m_MaterialPresetSelectionIndex = EditorGUI.Popup(rect, k_MaterialPresetLabel, m_MaterialPresetSelectionIndex, m_MaterialPresetNames);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    m_FontSharedMaterialProp.objectReferenceValue = m_MaterialPresets[m_MaterialPresetSelectionIndex];
+                    m_HavePropertiesChanged = true;
+                }
+
+                EditorStyles.popup.fixedHeight = oldHeight;
+                EditorStyles.popup.fontSize = oldSize;
+            }
+
+            // FONT STYLE
+            EditorGUI.BeginChangeCheck();
+
+            int v1, v2, v3, v4, v5, v6, v7;
+
+            if (EditorGUIUtility.wideMode)
+            {
+                rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight + 2f);
+
+                EditorGUI.PrefixLabel(rect, k_FontStyleLabel);
+
+                int styleValue = m_FontStyleProp.intValue;
+
+                rect.x += EditorGUIUtility.labelWidth;
+                rect.width -= EditorGUIUtility.labelWidth;
+
+                rect.width = Mathf.Max(25f, rect.width / 7f);
+
+                v1 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 1) == 1, k_BoldLabel, TMP_UIStyleManager.alignmentButtonLeft) ? 1 : 0; // Bold
+                rect.x += rect.width;
+                v2 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 2) == 2, k_ItalicLabel, TMP_UIStyleManager.alignmentButtonMid) ? 2 : 0; // Italics
+                rect.x += rect.width;
+                v3 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 4) == 4, k_UnderlineLabel, TMP_UIStyleManager.alignmentButtonMid) ? 4 : 0; // Underline
+                rect.x += rect.width;
+                v7 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 64) == 64, k_StrikethroughLabel, TMP_UIStyleManager.alignmentButtonRight) ? 64 : 0; // Strikethrough
+                rect.x += rect.width;
+
+                int selected = 0;
+
+                EditorGUI.BeginChangeCheck();
+                v4 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 8) == 8, k_LowercaseLabel, TMP_UIStyleManager.alignmentButtonLeft) ? 8 : 0; // Lowercase
+                if (EditorGUI.EndChangeCheck() && v4 > 0)
+                {
+                    selected = v4;
+                }
+                rect.x += rect.width;
+                EditorGUI.BeginChangeCheck();
+                v5 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 16) == 16, k_UppercaseLabel, TMP_UIStyleManager.alignmentButtonMid) ? 16 : 0; // Uppercase
+                if (EditorGUI.EndChangeCheck() && v5 > 0)
+                {
+                    selected = v5;
+                }
+                rect.x += rect.width;
+                EditorGUI.BeginChangeCheck();
+                v6 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 32) == 32, k_SmallcapsLabel, TMP_UIStyleManager.alignmentButtonRight) ? 32 : 0; // Smallcaps
+                if (EditorGUI.EndChangeCheck() && v6 > 0)
+                {
+                    selected = v6;
+                }
+
+                if (selected > 0)
+                {
+                    v4 = selected == 8 ? 8 : 0;
+                    v5 = selected == 16 ? 16 : 0;
+                    v6 = selected == 32 ? 32 : 0;
+                }
+            }
+            else
+            {
+                rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight + 2f);
+
+                EditorGUI.PrefixLabel(rect, k_FontStyleLabel);
+
+                int styleValue = m_FontStyleProp.intValue;
+
+                rect.x += EditorGUIUtility.labelWidth;
+                rect.width -= EditorGUIUtility.labelWidth;
+                rect.width = Mathf.Max(25f, rect.width / 4f);
+
+                v1 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 1) == 1, k_BoldLabel, TMP_UIStyleManager.alignmentButtonLeft) ? 1 : 0; // Bold
+                rect.x += rect.width;
+                v2 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 2) == 2, k_ItalicLabel, TMP_UIStyleManager.alignmentButtonMid) ? 2 : 0; // Italics
+                rect.x += rect.width;
+                v3 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 4) == 4, k_UnderlineLabel, TMP_UIStyleManager.alignmentButtonMid) ? 4 : 0; // Underline
+                rect.x += rect.width;
+                v7 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 64) == 64, k_StrikethroughLabel, TMP_UIStyleManager.alignmentButtonRight) ? 64 : 0; // Strikethrough
+
+                rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight + 2f);
+
+                rect.x += EditorGUIUtility.labelWidth;
+                rect.width -= EditorGUIUtility.labelWidth;
+
+                rect.width = Mathf.Max(25f, rect.width / 4f);
+
+                int selected = 0;
+
+                EditorGUI.BeginChangeCheck();
+                v4 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 8) == 8, k_LowercaseLabel, TMP_UIStyleManager.alignmentButtonLeft) ? 8 : 0; // Lowercase
+                if (EditorGUI.EndChangeCheck() && v4 > 0)
+                {
+                    selected = v4;
+                }
+                rect.x += rect.width;
+                EditorGUI.BeginChangeCheck();
+                v5 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 16) == 16, k_UppercaseLabel, TMP_UIStyleManager.alignmentButtonMid) ? 16 : 0; // Uppercase
+                if (EditorGUI.EndChangeCheck() && v5 > 0)
+                {
+                    selected = v5;
+                }
+                rect.x += rect.width;
+                EditorGUI.BeginChangeCheck();
+                v6 = TMP_EditorUtility.EditorToggle(rect, (styleValue & 32) == 32, k_SmallcapsLabel, TMP_UIStyleManager.alignmentButtonRight) ? 32 : 0; // Smallcaps
+                if (EditorGUI.EndChangeCheck() && v6 > 0)
+                {
+                    selected = v6;
+                }
+
+                if (selected > 0)
+                {
+                    v4 = selected == 8 ? 8 : 0;
+                    v5 = selected == 16 ? 16 : 0;
+                    v6 = selected == 32 ? 32 : 0;
+                }
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_FontStyleProp.intValue = v1 + v2 + v3 + v4 + v5 + v6 + v7;
+                m_HavePropertiesChanged = true;
+            }
+
+            // FONT SIZE
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUI.BeginDisabledGroup(m_AutoSizingProp.boolValue);
+            EditorGUILayout.PropertyField(m_FontSizeProp, k_FontSizeLabel, GUILayout.MaxWidth(EditorGUIUtility.labelWidth + 50f));
+            EditorGUI.EndDisabledGroup();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                float fontSize = Mathf.Clamp(m_FontSizeProp.floatValue, 0, 32767);
+
+                m_FontSizeProp.floatValue = fontSize;
+                m_FontSizeBaseProp.floatValue = fontSize;
+                m_HavePropertiesChanged = true;
+            }
+
+            EditorGUI.indentLevel += 1;
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_AutoSizingProp, k_AutoSizeLabel);
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (m_AutoSizingProp.boolValue == false)
+                    m_FontSizeProp.floatValue = m_FontSizeBaseProp.floatValue;
+
+                m_HavePropertiesChanged = true;
+            }
+
+            // Show auto sizing options
+            if (m_AutoSizingProp.boolValue)
+            {
+                rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight);
+
+                EditorGUI.PrefixLabel(rect, k_AutoSizeOptionsLabel);
+
+                int previousIndent = EditorGUI.indentLevel;
+
+                EditorGUI.indentLevel = 0;
+
+                rect.width = (rect.width - EditorGUIUtility.labelWidth) / 4f;
+                rect.x += EditorGUIUtility.labelWidth;
+
+                EditorGUIUtility.labelWidth = 24;
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.PropertyField(rect, m_FontSizeMinProp, k_MinLabel);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    float minSize = m_FontSizeMinProp.floatValue;
+
+                    minSize = Mathf.Max(0, minSize);
+
+                    m_FontSizeMinProp.floatValue = Mathf.Min(minSize, m_FontSizeMaxProp.floatValue);
+                    m_HavePropertiesChanged = true;
+                }
+                rect.x += rect.width;
+
+                EditorGUIUtility.labelWidth = 27;
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.PropertyField(rect, m_FontSizeMaxProp, k_MaxLabel);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    float maxSize = Mathf.Clamp(m_FontSizeMaxProp.floatValue, 0, 32767);
+
+                    m_FontSizeMaxProp.floatValue = Mathf.Max(m_FontSizeMinProp.floatValue, maxSize);
+                    m_HavePropertiesChanged = true;
+                }
+                rect.x += rect.width;
+
+                EditorGUI.BeginChangeCheck();
+                EditorGUIUtility.labelWidth = 36;
+                EditorGUI.PropertyField(rect, m_CharWidthMaxAdjProp, k_WdLabel);
+                rect.x += rect.width;
+                EditorGUIUtility.labelWidth = 28;
+                EditorGUI.PropertyField(rect, m_LineSpacingMaxProp, k_LineLabel);
+
+                EditorGUIUtility.labelWidth = 0;
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    m_CharWidthMaxAdjProp.floatValue = Mathf.Clamp(m_CharWidthMaxAdjProp.floatValue, 0, 50);
+                    m_LineSpacingMaxProp.floatValue = Mathf.Min(0, m_LineSpacingMaxProp.floatValue);
+                    m_HavePropertiesChanged = true;
+                }
+
+                EditorGUI.indentLevel = previousIndent;
+            }
+
+            EditorGUI.indentLevel -= 1;
+
+
+
+            EditorGUILayout.Space();
+        }
+
+        void DrawColor()
+        {
+            // FACE VERTEX COLOR
+            EditorGUI.BeginChangeCheck();
+            Color vertexColor = EditorGUILayout.ColorField(k_BaseColorLabel, m_FontColorProp.colorValue, false, true, false);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_FontColorProp.colorValue = vertexColor;
+                m_HavePropertiesChanged = true;
+            }
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_EnableVertexGradientProp, k_ColorGradientLabel);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_HavePropertiesChanged = true;
+            }
+
+            EditorGUIUtility.fieldWidth = 0;
+
+            if (m_EnableVertexGradientProp.boolValue)
+            {
+                EditorGUI.indentLevel += 1;
+
+                EditorGUI.BeginChangeCheck();
+
+                EditorGUILayout.PropertyField(m_FontColorGradientPresetProp, k_ColorPresetLabel);
+
+                SerializedObject obj = null;
+
+                SerializedProperty colorMode;
+
+                SerializedProperty topLeft;
+                SerializedProperty topRight;
+                SerializedProperty bottomLeft;
+                SerializedProperty bottomRight;
+
+                if (m_FontColorGradientPresetProp.objectReferenceValue == null)
+                {
+                    colorMode = m_ColorModeProp;
+                    topLeft = m_FontColorGradientProp.FindPropertyRelative("topLeft");
+                    topRight = m_FontColorGradientProp.FindPropertyRelative("topRight");
+                    bottomLeft = m_FontColorGradientProp.FindPropertyRelative("bottomLeft");
+                    bottomRight = m_FontColorGradientProp.FindPropertyRelative("bottomRight");
+                }
+                else
+                {
+                    obj = new SerializedObject(m_FontColorGradientPresetProp.objectReferenceValue);
+                    colorMode = obj.FindProperty("colorMode");
+                    topLeft = obj.FindProperty("topLeft");
+                    topRight = obj.FindProperty("topRight");
+                    bottomLeft = obj.FindProperty("bottomLeft");
+                    bottomRight = obj.FindProperty("bottomRight");
+                }
+
+                EditorGUILayout.PropertyField(colorMode, k_ColorModeLabel);
+
+                var rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+
+                EditorGUI.PrefixLabel(rect, k_CorenerColorsLabel);
+
+                rect.x += EditorGUIUtility.labelWidth;
+                rect.width = rect.width - EditorGUIUtility.labelWidth;
+
+                switch ((ColorMode)colorMode.enumValueIndex)
+                {
+                    case ColorMode.Single:
+                        TMP_EditorUtility.DrawColorProperty(rect, topLeft);
+
+                        topRight.colorValue = topLeft.colorValue;
+                        bottomLeft.colorValue = topLeft.colorValue;
+                        bottomRight.colorValue = topLeft.colorValue;
+                        break;
+                    case ColorMode.HorizontalGradient:
+                        rect.width /= 2f;
+
+                        TMP_EditorUtility.DrawColorProperty(rect, topLeft);
+
+                        rect.x += rect.width;
+
+                        TMP_EditorUtility.DrawColorProperty(rect, topRight);
+
+                        bottomLeft.colorValue = topLeft.colorValue;
+                        bottomRight.colorValue = topRight.colorValue;
+                        break;
+                    case ColorMode.VerticalGradient:
+                        TMP_EditorUtility.DrawColorProperty(rect, topLeft);
+
+                        rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+                        rect.x += EditorGUIUtility.labelWidth;
+
+                        TMP_EditorUtility.DrawColorProperty(rect, bottomLeft);
+
+                        topRight.colorValue = topLeft.colorValue;
+                        bottomRight.colorValue = bottomLeft.colorValue;
+                        break;
+                    case ColorMode.FourCornersGradient:
+                        rect.width /= 2f;
+
+                        TMP_EditorUtility.DrawColorProperty(rect, topLeft);
+
+                        rect.x += rect.width;
+
+                        TMP_EditorUtility.DrawColorProperty(rect, topRight);
+
+                        rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+                        rect.x += EditorGUIUtility.labelWidth;
+                        rect.width = (rect.width - EditorGUIUtility.labelWidth) / 2f;
+
+                        TMP_EditorUtility.DrawColorProperty(rect, bottomLeft);
+
+                        rect.x += rect.width;
+
+                        TMP_EditorUtility.DrawColorProperty(rect, bottomRight);
+                        break;
+                }
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    m_HavePropertiesChanged = true;
+                    if (obj != null)
+                    {
+                        obj.ApplyModifiedProperties();
+                        TMPro_EventManager.ON_COLOR_GRADIENT_PROPERTY_CHANGED(m_FontColorGradientPresetProp.objectReferenceValue as TMP_ColorGradient);
+                    }
+                }
+
+                EditorGUI.indentLevel -= 1;
+            }
+
+            EditorGUILayout.PropertyField(m_OverrideHtmlColorProp, k_OverrideTagsLabel);
+
+            EditorGUILayout.Space();
+        }
+
+        void DrawSpacing()
+        {
+            // CHARACTER, LINE & PARAGRAPH SPACING
+            EditorGUI.BeginChangeCheck();
+
+            Rect rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight);
+
+            EditorGUI.PrefixLabel(rect, k_SpacingOptionsLabel);
+
+            int oldIndent = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+
+            rect.x += EditorGUIUtility.labelWidth;
+            rect.width = (rect.width - EditorGUIUtility.labelWidth - 3f) / 2f;
+
+            EditorGUIUtility.labelWidth = Mathf.Min(rect.width * 0.55f, 80f);
+
+            EditorGUI.PropertyField(rect, m_CharacterSpacingProp, k_CharacterSpacingLabel);
+            rect.x += rect.width + 3f;
+            EditorGUI.PropertyField(rect, m_WordSpacingProp, k_WordSpacingLabel);
+
+            rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight);
+            EditorGUIUtility.labelWidth = 0;
+            rect.x += EditorGUIUtility.labelWidth;
+            rect.width = (rect.width - EditorGUIUtility.labelWidth -3f) / 2f;
+            EditorGUIUtility.labelWidth = Mathf.Min(rect.width * 0.55f, 80f);
+
+            EditorGUI.PropertyField(rect, m_LineSpacingProp, k_LineSpacingLabel);
+            rect.x += rect.width + 3f;
+            EditorGUI.PropertyField(rect, m_ParagraphSpacingProp, k_ParagraphSpacingLabel);
+
+            EditorGUIUtility.labelWidth = 0;
+            EditorGUI.indentLevel = oldIndent;
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_HavePropertiesChanged = true;
+            }
+
+            EditorGUILayout.Space();
+        }
+
+        void DrawAlignment()
+        {
+            // TEXT ALIGNMENT
+            EditorGUI.BeginChangeCheck();
+
+            Rect rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.currentViewWidth > 504 ? 20 : 40 + 3);
+
+            EditorGUI.PrefixLabel(rect, k_AlignmentLabel);
+            rect.x += EditorGUIUtility.labelWidth;
+
+            EditorGUI.PropertyField(rect, m_HorizontalAlignmentProp, GUIContent.none);
+            EditorGUI.PropertyField(rect, m_VerticalAlignmentProp, GUIContent.none);
+
+            // WRAPPING RATIOS shown if Justified mode is selected.
+            if (((HorizontalAlignmentOptions)m_HorizontalAlignmentProp.intValue & HorizontalAlignmentOptions.Justified) == HorizontalAlignmentOptions.Justified || ((HorizontalAlignmentOptions)m_HorizontalAlignmentProp.intValue & HorizontalAlignmentOptions.Flush) == HorizontalAlignmentOptions.Flush)
+                DrawPropertySlider(k_WrapMixLabel, m_WordWrappingRatiosProp);
+
+            if (EditorGUI.EndChangeCheck())
+                m_HavePropertiesChanged = true;
+
+            EditorGUILayout.Space();
+        }
+
+        void DrawWrappingOverflow()
+        {
+            // TEXT WRAPPING
+            EditorGUI.BeginChangeCheck();
+            int wrapSelection = EditorGUILayout.Popup(k_WrappingLabel, m_EnableWordWrappingProp.boolValue ? 1 : 0, k_WrappingOptions);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_EnableWordWrappingProp.boolValue = wrapSelection == 1;
+                m_HavePropertiesChanged = true;
+                m_TextComponent.m_isInputParsingRequired = true;
+            }
+
+            // TEXT OVERFLOW
+            EditorGUI.BeginChangeCheck();
+
+            if ((TextOverflowModes)m_TextOverflowModeProp.enumValueIndex == TextOverflowModes.Linked)
+            {
+                EditorGUILayout.BeginHorizontal();
+
+                float fieldWidth = EditorGUIUtility.fieldWidth;
+                EditorGUIUtility.fieldWidth = 65;
+                EditorGUILayout.PropertyField(m_TextOverflowModeProp, k_OverflowLabel);
+                EditorGUIUtility.fieldWidth = fieldWidth;
+
+                EditorGUILayout.PropertyField(m_LinkedTextComponentProp, GUIContent.none);
+
+                EditorGUILayout.EndHorizontal();
+
+                if (GUI.changed)
+                {
+                    TMP_Text linkedComponent = m_LinkedTextComponentProp.objectReferenceValue as TMP_Text;
+
+                    if (linkedComponent == null)
+                    {
+                        m_LinkedTextComponentProp.objectReferenceValue = null;
+
+                        if (m_PreviousLinkedTextComponent != null)
+                            m_TextComponent.ReleaseLinkedTextComponent(m_PreviousLinkedTextComponent);
+                    }
+                    else if (m_TextComponent.IsSelfOrLinkedAncestor(linkedComponent))
+                    {
+                        m_LinkedTextComponentProp.objectReferenceValue = m_PreviousLinkedTextComponent;
+                    }
+                    else
+                    {
+                        if (m_PreviousLinkedTextComponent != null)
+                            m_TextComponent.ReleaseLinkedTextComponent(m_PreviousLinkedTextComponent);
+
+                        m_LinkedTextComponentProp.objectReferenceValue = linkedComponent;
+                        linkedComponent.parentLinkedComponent = m_TextComponent;
+                        m_PreviousLinkedTextComponent = linkedComponent;
+                    }
+                }
+            }
+            else if ((TextOverflowModes)m_TextOverflowModeProp.enumValueIndex == TextOverflowModes.Page)
+            {
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.PropertyField(m_TextOverflowModeProp, k_OverflowLabel);
+                EditorGUILayout.PropertyField(m_PageToDisplayProp, GUIContent.none);
+                EditorGUILayout.EndHorizontal();
+
+                if (m_PreviousLinkedTextComponent)
+                {
+                    m_TextComponent.ReleaseLinkedTextComponent(m_PreviousLinkedTextComponent);
+
+                    m_TextComponent.linkedTextComponent = null;
+                }
+            }
+            else
+            {
+                EditorGUILayout.PropertyField(m_TextOverflowModeProp, k_OverflowLabel);
+
+                if (m_PreviousLinkedTextComponent)
+                {
+                    m_TextComponent.ReleaseLinkedTextComponent(m_PreviousLinkedTextComponent);
+
+                    m_TextComponent.linkedTextComponent = null;
+                }
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_HavePropertiesChanged = true;
+                m_TextComponent.m_isInputParsingRequired = true;
+            }
+
+            EditorGUILayout.Space();
+        }
+
+        protected abstract void DrawExtraSettings();
+
+        protected void DrawMargins()
+        {
+            EditorGUI.BeginChangeCheck();
+            DrawMarginProperty(m_MarginProp, k_MarginsLabel);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_HavePropertiesChanged = true;
+            }
+
+            EditorGUILayout.Space();
+        }
+
+        protected void DrawGeometrySorting()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(m_GeometrySortingOrderProp, k_GeometrySortingLabel);
+
+            if (EditorGUI.EndChangeCheck())
+                m_HavePropertiesChanged = true;
+
+            EditorGUILayout.Space();
+        }
+
+        protected void DrawIsTextObjectScaleStatic()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(m_IsTextObjectScaleStaticProp, k_IsTextObjectScaleStatic);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_TextComponent.isTextObjectScaleStatic = m_IsTextObjectScaleStaticProp.boolValue;
+                m_HavePropertiesChanged = true;
+            }
+
+            EditorGUILayout.Space();
+        }
+
+
+        protected void DrawRichText()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(m_IsRichTextProp, k_RichTextLabel);
+            if (EditorGUI.EndChangeCheck())
+                m_HavePropertiesChanged = true;
+        }
+
+        protected void DrawParsing()
+        {
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_EnableEscapeCharacterParsingProp, k_EscapeCharactersLabel);
+            EditorGUILayout.PropertyField(m_UseMaxVisibleDescenderProp, k_VisibleDescenderLabel);
+
+            if (EditorGUI.EndChangeCheck())
+                m_HavePropertiesChanged = true;
+
+            EditorGUILayout.Space();
+        }
+
+        protected void DrawSpriteAsset()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(m_SpriteAssetProp, k_SpriteAssetLabel, true);
+
+            if (EditorGUI.EndChangeCheck())
+                m_HavePropertiesChanged = true;
+
+            EditorGUILayout.Space();
+        }
+
+        protected void DrawStyleSheet()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(m_StyleSheetAssetProp, k_StyleSheetAssetLabel, true);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_StyleNames = GetStyleNames();
+                m_HavePropertiesChanged = true;
+            }
+
+            EditorGUILayout.Space();
+        }
+
+        protected void DrawTextureMapping()
+        {
+            // TEXTURE MAPPING OPTIONS
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_HorizontalMappingProp, k_HorizontalMappingLabel);
+            EditorGUILayout.PropertyField(m_VerticalMappingProp, k_VerticalMappingLabel);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_HavePropertiesChanged = true;
+            }
+
+            // UV OPTIONS
+            if (m_HorizontalMappingProp.enumValueIndex > 0)
+            {
+                EditorGUI.BeginChangeCheck();
+                EditorGUILayout.PropertyField(m_UvLineOffsetProp, k_LineOffsetLabel, GUILayout.MinWidth(70f));
+                if (EditorGUI.EndChangeCheck())
+                {
+                    m_HavePropertiesChanged = true;
+                }
+            }
+
+            EditorGUILayout.Space();
+        }
+
+        protected void DrawKerning()
+        {
+            // KERNING
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_EnableKerningProp, k_KerningLabel);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_HavePropertiesChanged = true;
+            }
+        }
+
+        protected void DrawPadding()
+        {
+            // EXTRA PADDING
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_EnableExtraPaddingProp, k_PaddingLabel);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_HavePropertiesChanged = true;
+                m_CheckPaddingRequiredProp.boolValue = true;
+            }
+        }
+
+        /// <summary>
+        /// Method to retrieve the material presets that match the currently selected font asset.
+        /// </summary>
+        protected GUIContent[] GetMaterialPresets()
+        {
+            TMP_FontAsset fontAsset = m_FontAssetProp.objectReferenceValue as TMP_FontAsset;
+            if (fontAsset == null) return null;
+
+            m_MaterialPresets = TMP_EditorUtility.FindMaterialReferences(fontAsset);
+            m_MaterialPresetNames = new GUIContent[m_MaterialPresets.Length];
+
+            m_MaterialPresetIndexLookup.Clear();
+
+            for (int i = 0; i < m_MaterialPresetNames.Length; i++)
+            {
+                m_MaterialPresetNames[i] = new GUIContent(m_MaterialPresets[i].name);
+
+                m_MaterialPresetIndexLookup.Add(m_MaterialPresets[i].GetInstanceID(), i);
+
+                //if (m_TargetMaterial.GetInstanceID() == m_MaterialPresets[i].GetInstanceID())
+                //    m_MaterialPresetSelectionIndex = i;
+            }
+
+            m_IsPresetListDirty = false;
+
+            return m_MaterialPresetNames;
+        }
+
+        protected GUIContent[] GetStyleNames()
+        {
+            k_AvailableStyles.Clear();
+            m_TextStyleIndexLookup.Clear();
+            m_Styles.Clear();
+
+            // First style on the list is always the Normal default style.
+            TMP_Style styleNormal = TMP_Style.NormalStyle;
+
+            m_Styles.Add(styleNormal);
+            m_TextStyleIndexLookup.Add(styleNormal.hashCode, 0);
+
+            k_AvailableStyles.Add(styleNormal.hashCode, styleNormal);
+
+            // Get styles from Style Sheet potentially assigned to the text object.
+            TMP_StyleSheet localStyleSheet = (TMP_StyleSheet)m_StyleSheetAssetProp.objectReferenceValue;
+
+            if (localStyleSheet != null)
+            {
+                int styleCount = localStyleSheet.styles.Count;
+
+                for (int i = 0; i < styleCount; i++)
+                {
+                    TMP_Style style = localStyleSheet.styles[i];
+
+                    if (k_AvailableStyles.ContainsKey(style.hashCode) == false)
+                    {
+                        k_AvailableStyles.Add(style.hashCode, style);
+                        m_Styles.Add(style);
+                        m_TextStyleIndexLookup.Add(style.hashCode, m_TextStyleIndexLookup.Count);
+                    }
+                }
+            }
+
+            // Get styles from TMP Settings' default style sheet.
+            TMP_StyleSheet globalStyleSheet = TMP_Settings.defaultStyleSheet;
+
+            if (globalStyleSheet != null)
+            {
+                int styleCount = globalStyleSheet.styles.Count;
+
+                for (int i = 0; i < styleCount; i++)
+                {
+                    TMP_Style style = globalStyleSheet.styles[i];
+
+                    if (k_AvailableStyles.ContainsKey(style.hashCode) == false)
+                    {
+                        k_AvailableStyles.Add(style.hashCode, style);
+                        m_Styles.Add(style);
+                        m_TextStyleIndexLookup.Add(style.hashCode, m_TextStyleIndexLookup.Count);
+                    }
+                }
+            }
+
+            // Create array that will contain the list of available styles.
+            GUIContent[] styleNames = k_AvailableStyles.Values.Select(item => new GUIContent(item.name)).ToArray();
+
+            // Set text style index
+            m_TextStyleIndexLookup.TryGetValue(m_TextStyleHashCodeProp.intValue, out m_StyleSelectionIndex);
+
+            return styleNames;
+        }
+
+        // DRAW MARGIN PROPERTY
+        protected void DrawMarginProperty(SerializedProperty property, GUIContent label)
+        {
+            Rect rect = EditorGUILayout.GetControlRect(false, 2 * 18);
+
+            EditorGUI.BeginProperty(rect, label, property);
+
+            Rect pos0 = new Rect(rect.x, rect.y + 2, rect.width - 15, 18);
+
+            float width = rect.width + 3;
+            pos0.width = EditorGUIUtility.labelWidth;
+            EditorGUI.PrefixLabel(pos0, label);
+
+            Vector4 margins = property.vector4Value;
+
+            float widthB = width - EditorGUIUtility.labelWidth;
+            float fieldWidth = widthB / 4;
+            pos0.width = Mathf.Max(fieldWidth - 5, 45f);
+
+            // Labels
+            pos0.x = EditorGUIUtility.labelWidth + 15;
+            margins.x = DrawMarginField(pos0, "Left", margins.x);
+
+            pos0.x += fieldWidth;
+            margins.y = DrawMarginField(pos0, "Top", margins.y);
+
+            pos0.x += fieldWidth;
+            margins.z = DrawMarginField(pos0, "Right", margins.z);
+
+            pos0.x += fieldWidth;
+            margins.w = DrawMarginField(pos0, "Bottom", margins.w);
+
+            property.vector4Value = margins;
+
+            EditorGUI.EndProperty();
+        }
+
+        float DrawMarginField(Rect position, string label, float value)
+        {
+            int controlId = GUIUtility.GetControlID(FocusType.Keyboard, position);
+            EditorGUI.PrefixLabel(position, controlId, new GUIContent(label));
+
+            Rect dragZone = new Rect(position.x, position.y, position.width, position.height);
+            position.y += EditorGUIUtility.singleLineHeight;
+
+            return EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, position, dragZone, controlId, value, EditorGUI.kFloatFieldFormatString, EditorStyles.numberField, true);
+        }
+
+        protected void DrawPropertySlider(GUIContent label, SerializedProperty property)
+        {
+            Rect rect = EditorGUILayout.GetControlRect(false, 17);
+
+            GUIContent content = label ?? GUIContent.none;
+            EditorGUI.Slider(new Rect(rect.x, rect.y, rect.width, rect.height), property, 0.0f, 1.0f, content);
+        }
+
+        protected abstract bool IsMixSelectionTypes();
+
+        // Special Handling of Undo / Redo Events.
+        protected abstract void OnUndoRedo();
+
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_BaseEditorPanel.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 91950f78729ab144aa36e94690b28fad
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_BaseShaderGUI.cs

@@ -0,0 +1,551 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace TMPro.EditorUtilities
+{
+    /// <summary>Base class for TextMesh Pro shader GUIs.</summary>
+    public abstract class TMP_BaseShaderGUI : ShaderGUI
+    {
+        /// <summary>Representation of a #pragma shader_feature.</summary>
+        /// <description>It is assumed that the first feature option is for no keyword (underscores).</description>
+        protected class ShaderFeature
+        {
+            public string undoLabel;
+
+            public GUIContent label;
+
+            /// <summary>The keyword labels, for display. Include the no-keyword as the first option.</summary>
+            public GUIContent[] keywordLabels;
+
+            /// <summary>The shader keywords. Exclude the no-keyword option.</summary>
+            public string[] keywords;
+
+            int m_State;
+
+            public bool Active
+            {
+                get { return m_State >= 0; }
+            }
+
+            public int State
+            {
+                get { return m_State; }
+            }
+
+            public void ReadState(Material material)
+            {
+                for (int i = 0; i < keywords.Length; i++)
+                {
+                    if (material.IsKeywordEnabled(keywords[i]))
+                    {
+                        m_State = i;
+                        return;
+                    }
+                }
+
+                m_State = -1;
+            }
+
+            public void SetActive(bool active, Material material)
+            {
+                m_State = active ? 0 : -1;
+                SetStateKeywords(material);
+            }
+
+            public void DoPopup(MaterialEditor editor, Material material)
+            {
+                EditorGUI.BeginChangeCheck();
+                int selection = EditorGUILayout.Popup(label, m_State + 1, keywordLabels);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    m_State = selection - 1;
+                    editor.RegisterPropertyChangeUndo(undoLabel);
+                    SetStateKeywords(material);
+                }
+            }
+
+            void SetStateKeywords(Material material)
+            {
+                for (int i = 0; i < keywords.Length; i++)
+                {
+                    if (i == m_State)
+                    {
+                        material.EnableKeyword(keywords[i]);
+                    }
+                    else
+                    {
+                        material.DisableKeyword(keywords[i]);
+                    }
+                }
+            }
+        }
+
+        static GUIContent s_TempLabel = new GUIContent();
+
+        protected static bool s_DebugExtended;
+
+        static int s_UndoRedoCount, s_LastSeenUndoRedoCount;
+
+        static float[][] s_TempFloats =
+        {
+            null, new float[1], new float[2], new float[3], new float[4]
+        };
+
+        protected static GUIContent[] s_XywhVectorLabels =
+        {
+            new GUIContent("X"),
+            new GUIContent("Y"),
+            new GUIContent("W", "Width"),
+            new GUIContent("H", "Height")
+        };
+
+        protected static GUIContent[] s_LbrtVectorLabels =
+        {
+            new GUIContent("L", "Left"),
+            new GUIContent("B", "Bottom"),
+            new GUIContent("R", "Right"),
+            new GUIContent("T", "Top")
+        };
+
+        protected static GUIContent[] s_CullingTypeLabels =
+        {
+            new GUIContent("Off"),
+            new GUIContent("Front"),
+            new GUIContent("Back")
+        };
+
+        static TMP_BaseShaderGUI()
+        {
+            // Keep track of how many undo/redo events happened.
+            Undo.undoRedoPerformed += () => s_UndoRedoCount += 1;
+        }
+
+        bool m_IsNewGUI = true;
+
+        float m_DragAndDropMinY;
+
+        protected MaterialEditor m_Editor;
+
+        protected Material m_Material;
+
+        protected MaterialProperty[] m_Properties;
+
+        void PrepareGUI()
+        {
+            m_IsNewGUI = false;
+            ShaderUtilities.GetShaderPropertyIDs();
+
+            // New GUI just got constructed. This happens in response to a selection,
+            // but also after undo/redo events.
+            if (s_LastSeenUndoRedoCount != s_UndoRedoCount)
+            {
+                // There's been at least one undo/redo since the last time this GUI got constructed.
+                // Maybe the undo/redo was for this material? Assume that is was.
+                TMPro_EventManager.ON_MATERIAL_PROPERTY_CHANGED(true, m_Material as Material);
+            }
+
+            s_LastSeenUndoRedoCount = s_UndoRedoCount;
+        }
+
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
+        {
+            m_Editor = materialEditor;
+            m_Material = materialEditor.target as Material;
+            this.m_Properties = properties;
+
+            if (m_IsNewGUI)
+            {
+                PrepareGUI();
+            }
+
+            DoDragAndDropBegin();
+            EditorGUI.BeginChangeCheck();
+            DoGUI();
+            if (EditorGUI.EndChangeCheck())
+            {
+                TMPro_EventManager.ON_MATERIAL_PROPERTY_CHANGED(true, m_Material);
+            }
+
+            DoDragAndDropEnd();
+        }
+
+        /// <summary>Override this method to create the specific shader GUI.</summary>
+        protected abstract void DoGUI();
+
+        static string[] s_PanelStateLabel = new string[] { "\t- <i>Click to collapse</i> -", "\t- <i>Click to expand</i>  -" };
+
+        protected bool BeginPanel(string panel, bool expanded)
+        {
+            EditorGUI.indentLevel = 0;
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+            Rect r = EditorGUI.IndentedRect(GUILayoutUtility.GetRect(20, 18));
+            r.x += 20;
+            r.width += 6;
+
+            bool enabled = GUI.enabled;
+            GUI.enabled = true;
+            expanded = TMP_EditorUtility.EditorToggle(r, expanded, new GUIContent(panel), TMP_UIStyleManager.panelTitle);
+            r.width -= 30;
+            EditorGUI.LabelField(r, new GUIContent(expanded ? s_PanelStateLabel[0] : s_PanelStateLabel[1]), TMP_UIStyleManager.rightLabel);
+            GUI.enabled = enabled;
+
+            EditorGUI.indentLevel += 1;
+            EditorGUI.BeginDisabledGroup(false);
+
+            return expanded;
+        }
+
+        protected bool BeginPanel(string panel, ShaderFeature feature, bool expanded, bool readState = true)
+        {
+            EditorGUI.indentLevel = 0;
+
+            if (readState)
+            {
+                feature.ReadState(m_Material);
+            }
+
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.BeginVertical(EditorStyles.helpBox);
+            GUILayout.BeginHorizontal();
+
+            Rect r = EditorGUI.IndentedRect(GUILayoutUtility.GetRect(20, 20, GUILayout.Width(20f)));
+            bool active = EditorGUI.Toggle(r, feature.Active);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_Editor.RegisterPropertyChangeUndo(feature.undoLabel);
+                feature.SetActive(active, m_Material);
+            }
+
+            r = EditorGUI.IndentedRect(GUILayoutUtility.GetRect(20, 18));
+            r.width += 6;
+
+            bool enabled = GUI.enabled;
+            GUI.enabled = true;
+            expanded = TMP_EditorUtility.EditorToggle(r, expanded, new GUIContent(panel), TMP_UIStyleManager.panelTitle);
+            r.width -= 10;
+            EditorGUI.LabelField(r, new GUIContent(expanded ? s_PanelStateLabel[0] : s_PanelStateLabel[1]), TMP_UIStyleManager.rightLabel);
+            GUI.enabled = enabled;
+
+            GUILayout.EndHorizontal();
+
+            EditorGUI.indentLevel += 1;
+            EditorGUI.BeginDisabledGroup(!active);
+
+            return expanded;
+        }
+
+        public void EndPanel()
+        {
+            EditorGUI.EndDisabledGroup();
+            EditorGUI.indentLevel -= 1;
+            EditorGUILayout.EndVertical();
+        }
+
+        MaterialProperty BeginProperty(string name)
+        {
+            MaterialProperty property = FindProperty(name, m_Properties);
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.showMixedValue = property.hasMixedValue;
+            m_Editor.BeginAnimatedCheck(Rect.zero, property);
+
+            return property;
+        }
+
+        bool EndProperty()
+        {
+            m_Editor.EndAnimatedCheck();
+            EditorGUI.showMixedValue = false;
+            return EditorGUI.EndChangeCheck();
+        }
+
+        protected void DoPopup(string name, string label, GUIContent[] options)
+        {
+            MaterialProperty property = BeginProperty(name);
+            s_TempLabel.text = label;
+            int index = EditorGUILayout.Popup(s_TempLabel, (int)property.floatValue, options);
+            if (EndProperty())
+            {
+                property.floatValue = index;
+            }
+        }
+
+        protected void DoCubeMap(string name, string label)
+        {
+            DoTexture(name, label, typeof(Cubemap));
+        }
+
+        protected void DoTexture2D(string name, string label, bool withTilingOffset = false, string[] speedNames = null)
+        {
+            DoTexture(name, label, typeof(Texture2D), withTilingOffset, speedNames);
+        }
+
+        void DoTexture(string name, string label, System.Type type, bool withTilingOffset = false, string[] speedNames = null)
+        {
+            MaterialProperty property = FindProperty(name, m_Properties);
+            m_Editor.BeginAnimatedCheck(Rect.zero, property);
+
+            Rect rect = EditorGUILayout.GetControlRect(true, 60f);
+            float totalWidth = rect.width;
+            rect.width = EditorGUIUtility.labelWidth + 60f;
+            s_TempLabel.text = label;
+
+            EditorGUI.BeginChangeCheck();
+            Object tex = EditorGUI.ObjectField(rect, s_TempLabel, property.textureValue, type, false);
+            if (EditorGUI.EndChangeCheck())
+            {
+                property.textureValue = tex as Texture;
+            }
+
+            rect.x += rect.width + 4f;
+            rect.width = totalWidth - rect.width - 4f;
+            rect.height = EditorGUIUtility.singleLineHeight;
+
+            if (withTilingOffset)
+            {
+                DoTilingOffset(rect, property);
+                rect.y += (rect.height + 2f) * 2f;
+            }
+
+            m_Editor.EndAnimatedCheck();
+
+            if (speedNames != null)
+            {
+                DoUVSpeed(rect, speedNames);
+            }
+        }
+
+        void DoTilingOffset(Rect rect, MaterialProperty property)
+        {
+            float labelWidth = EditorGUIUtility.labelWidth;
+            int indentLevel = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+            EditorGUIUtility.labelWidth = Mathf.Min(40f, rect.width * 0.20f);
+
+            Vector4 vector = property.textureScaleAndOffset;
+
+            bool changed = false;
+            float[] values = s_TempFloats[2];
+
+            s_TempLabel.text = "Tiling";
+            Rect vectorRect = EditorGUI.PrefixLabel(rect, s_TempLabel);
+            values[0] = vector.x;
+            values[1] = vector.y;
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.MultiFloatField(vectorRect, s_XywhVectorLabels, values);
+            if (EditorGUI.EndChangeCheck())
+            {
+                vector.x = values[0];
+                vector.y = values[1];
+                changed = true;
+            }
+
+            rect.y += rect.height + 2f;
+            s_TempLabel.text = "Offset";
+            vectorRect = EditorGUI.PrefixLabel(rect, s_TempLabel);
+            values[0] = vector.z;
+            values[1] = vector.w;
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.MultiFloatField(vectorRect, s_XywhVectorLabels, values);
+            if (EditorGUI.EndChangeCheck())
+            {
+                vector.z = values[0];
+                vector.w = values[1];
+                changed = true;
+            }
+
+            if (changed)
+            {
+                property.textureScaleAndOffset = vector;
+            }
+
+            EditorGUIUtility.labelWidth = labelWidth;
+            EditorGUI.indentLevel = indentLevel;
+        }
+
+        protected void DoUVSpeed(Rect rect, string[] names)
+        {
+            float labelWidth = EditorGUIUtility.labelWidth;
+            int indentLevel = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+            EditorGUIUtility.labelWidth = Mathf.Min(40f, rect.width * 0.20f);
+
+            s_TempLabel.text = "Speed";
+            rect = EditorGUI.PrefixLabel(rect, s_TempLabel);
+
+            EditorGUIUtility.labelWidth = 13f;
+            rect.width = rect.width * 0.5f - 1f;
+            DoFloat(rect, names[0], "X");
+            rect.x += rect.width + 2f;
+            DoFloat(rect, names[1], "Y");
+            EditorGUIUtility.labelWidth = labelWidth;
+            EditorGUI.indentLevel = indentLevel;
+        }
+
+        protected void DoToggle(string name, string label)
+        {
+            MaterialProperty property = BeginProperty(name);
+            s_TempLabel.text = label;
+            bool value = EditorGUILayout.Toggle(s_TempLabel, property.floatValue == 1f);
+            if (EndProperty())
+            {
+                property.floatValue = value ? 1f : 0f;
+            }
+        }
+
+        protected void DoFloat(string name, string label)
+        {
+            MaterialProperty property = BeginProperty(name);
+            Rect rect = EditorGUILayout.GetControlRect();
+            rect.width = EditorGUIUtility.labelWidth + 55f;
+            s_TempLabel.text = label;
+            float value = EditorGUI.FloatField(rect, s_TempLabel, property.floatValue);
+            if (EndProperty())
+            {
+                property.floatValue = value;
+            }
+        }
+
+        protected void DoColor(string name, string label)
+        {
+            MaterialProperty property = BeginProperty(name);
+            s_TempLabel.text = label;
+            Color value = EditorGUI.ColorField(EditorGUILayout.GetControlRect(), s_TempLabel, property.colorValue, false, true, true);
+            if (EndProperty())
+            {
+                property.colorValue = value;
+            }
+        }
+
+        void DoFloat(Rect rect, string name, string label)
+        {
+            MaterialProperty property = BeginProperty(name);
+            s_TempLabel.text = label;
+            float value = EditorGUI.FloatField(rect, s_TempLabel, property.floatValue);
+            if (EndProperty())
+            {
+                property.floatValue = value;
+            }
+        }
+
+        protected void DoSlider(string name, string label)
+        {
+            MaterialProperty property = BeginProperty(name);
+            Vector2 range = property.rangeLimits;
+            s_TempLabel.text = label;
+            float value = EditorGUI.Slider(
+                EditorGUILayout.GetControlRect(), s_TempLabel, property.floatValue, range.x, range.y
+            );
+            if (EndProperty())
+            {
+                property.floatValue = value;
+            }
+        }
+
+        protected void DoVector3(string name, string label)
+        {
+            MaterialProperty property = BeginProperty(name);
+            s_TempLabel.text = label;
+            Vector4 value = EditorGUILayout.Vector3Field(s_TempLabel, property.vectorValue);
+            if (EndProperty())
+            {
+                property.vectorValue = value;
+            }
+        }
+
+        protected void DoVector(string name, string label, GUIContent[] subLabels)
+        {
+            MaterialProperty property = BeginProperty(name);
+            Rect rect = EditorGUILayout.GetControlRect();
+            s_TempLabel.text = label;
+            rect = EditorGUI.PrefixLabel(rect, s_TempLabel);
+            Vector4 vector = property.vectorValue;
+
+            float[] values = s_TempFloats[subLabels.Length];
+            for (int i = 0; i < subLabels.Length; i++)
+            {
+                values[i] = vector[i];
+            }
+
+            EditorGUI.MultiFloatField(rect, subLabels, values);
+            if (EndProperty())
+            {
+                for (int i = 0; i < subLabels.Length; i++)
+                {
+                    vector[i] = values[i];
+                }
+
+                property.vectorValue = vector;
+            }
+        }
+
+        void DoDragAndDropBegin()
+        {
+            m_DragAndDropMinY = GUILayoutUtility.GetRect(0f, 0f, GUILayout.ExpandWidth(true)).y;
+        }
+
+        void DoDragAndDropEnd()
+        {
+            Rect rect = GUILayoutUtility.GetRect(0f, 0f, GUILayout.ExpandWidth(true));
+            Event evt = Event.current;
+            if (evt.type == EventType.DragUpdated)
+            {
+                DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
+                evt.Use();
+            }
+            else if (
+                evt.type == EventType.DragPerform &&
+                Rect.MinMaxRect(rect.xMin, m_DragAndDropMinY, rect.xMax, rect.yMax).Contains(evt.mousePosition)
+            )
+            {
+                DragAndDrop.AcceptDrag();
+                evt.Use();
+                Material droppedMaterial = DragAndDrop.objectReferences[0] as Material;
+                if (droppedMaterial && droppedMaterial != m_Material)
+                {
+                    PerformDrop(droppedMaterial);
+                }
+            }
+        }
+
+        void PerformDrop(Material droppedMaterial)
+        {
+            Texture droppedTex = droppedMaterial.GetTexture(ShaderUtilities.ID_MainTex);
+            if (!droppedTex)
+            {
+                return;
+            }
+
+            Texture currentTex = m_Material.GetTexture(ShaderUtilities.ID_MainTex);
+            TMP_FontAsset requiredFontAsset = null;
+            if (droppedTex != currentTex)
+            {
+                requiredFontAsset = TMP_EditorUtility.FindMatchingFontAsset(droppedMaterial);
+                if (!requiredFontAsset)
+                {
+                    return;
+                }
+            }
+
+            foreach (GameObject o in Selection.gameObjects)
+            {
+                if (requiredFontAsset)
+                {
+                    TMP_Text textComponent = o.GetComponent<TMP_Text>();
+                    if (textComponent)
+                    {
+                        Undo.RecordObject(textComponent, "Font Asset Change");
+                        textComponent.font = requiredFontAsset;
+                    }
+                }
+
+                TMPro_EventManager.ON_DRAG_AND_DROP_MATERIAL_CHANGED(o, m_Material, droppedMaterial);
+                EditorUtility.SetDirty(o);
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_BaseShaderGUI.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 438efd46088d408d8a53f707fa68d976
+timeCreated: 1469844810
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_BitmapShaderGUI.cs

@@ -0,0 +1,93 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace TMPro.EditorUtilities
+{
+    public class TMP_BitmapShaderGUI : TMP_BaseShaderGUI
+    {
+        static bool s_Face = true;
+
+        protected override void DoGUI()
+        {
+            s_Face = BeginPanel("Face", s_Face);
+            if (s_Face)
+            {
+                DoFacePanel();
+            }
+
+            EndPanel();
+
+            s_DebugExtended = BeginPanel("Debug Settings", s_DebugExtended);
+            if (s_DebugExtended)
+            {
+                DoDebugPanel();
+            }
+
+            EndPanel();
+        }
+
+        void DoFacePanel()
+        {
+            EditorGUI.indentLevel += 1;
+            if (m_Material.HasProperty(ShaderUtilities.ID_FaceTex))
+            {
+                DoColor("_FaceColor", "Color");
+                DoTexture2D("_FaceTex", "Texture", true);
+            }
+            else
+            {
+                DoColor("_Color", "Color");
+                DoSlider("_DiffusePower", "Diffuse Power");
+            }
+
+            EditorGUI.indentLevel -= 1;
+
+            EditorGUILayout.Space();
+        }
+
+        void DoDebugPanel()
+        {
+            EditorGUI.indentLevel += 1;
+            DoTexture2D("_MainTex", "Font Atlas");
+            if (m_Material.HasProperty(ShaderUtilities.ID_VertexOffsetX))
+            {
+                if (m_Material.HasProperty(ShaderUtilities.ID_Padding))
+                {
+                    EditorGUILayout.Space();
+                    DoFloat("_Padding", "Padding");
+                }
+                
+                EditorGUILayout.Space();
+                DoFloat("_VertexOffsetX", "Offset X");
+                DoFloat("_VertexOffsetY", "Offset Y");
+            }
+
+            if (m_Material.HasProperty(ShaderUtilities.ID_MaskSoftnessX))
+            {
+                EditorGUILayout.Space();
+                DoFloat("_MaskSoftnessX", "Softness X");
+                DoFloat("_MaskSoftnessY", "Softness Y");
+                DoVector("_ClipRect", "Clip Rect", s_LbrtVectorLabels);
+            }
+
+            if (m_Material.HasProperty(ShaderUtilities.ID_StencilID))
+            {
+                EditorGUILayout.Space();
+                DoFloat("_Stencil", "Stencil ID");
+                DoFloat("_StencilComp", "Stencil Comp");
+            }
+
+            if (m_Material.HasProperty(ShaderUtilities.ShaderTag_CullMode))
+            {
+                EditorGUILayout.Space();
+                DoPopup("_CullMode", "Cull Mode", s_CullingTypeLabels);
+            }
+
+            EditorGUILayout.Space();
+
+            EditorGUI.indentLevel -= 1;
+
+            EditorGUILayout.Space();
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_BitmapShaderGUI.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 806de5a9211448c8b65c8435ebb48dd4
+timeCreated: 1469998850
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_CharacterPropertyDrawer.cs

@@ -0,0 +1,235 @@
+using UnityEngine;
+using UnityEngine.TextCore;
+using UnityEngine.TextCore.LowLevel;
+using UnityEditor;
+using System.Collections;
+
+
+namespace TMPro.EditorUtilities
+{
+    [CustomPropertyDrawer(typeof(TMP_Character))]
+    public class TMP_CharacterPropertyDrawer : PropertyDrawer
+    {
+        private string k_ColorProperty = "_Color";
+
+        int m_GlyphSelectedForEditing = -1;
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            SerializedProperty prop_Unicode = property.FindPropertyRelative("m_Unicode");
+            SerializedProperty prop_GlyphIndex = property.FindPropertyRelative("m_GlyphIndex");
+            SerializedProperty prop_Scale = property.FindPropertyRelative("m_Scale");
+
+
+            GUIStyle style = new GUIStyle(EditorStyles.label);
+            style.richText = true;
+
+            EditorGUIUtility.labelWidth = 40f;
+            EditorGUIUtility.fieldWidth = 50;
+
+            Rect rect = new Rect(position.x + 50, position.y, position.width, 49);
+
+            // Display non-editable fields
+            if (GUI.enabled == false)
+            {
+                int unicode = prop_Unicode.intValue;
+                EditorGUI.LabelField(new Rect(rect.x, rect.y, 120f, 18), new GUIContent("Unicode: <color=#FFFF80>0x" + unicode.ToString("X") + "</color>"), style);
+                EditorGUI.LabelField(new Rect(rect.x + 115, rect.y, 120f, 18), unicode <= 0xFFFF ? new GUIContent("UTF16: <color=#FFFF80>\\u" + unicode.ToString("X4") + "</color>") : new GUIContent("UTF32: <color=#FFFF80>\\U" + unicode.ToString("X8") + "</color>"), style);
+                EditorGUI.LabelField(new Rect(rect.x, rect.y + 18, 120, 18), new GUIContent("Glyph ID: <color=#FFFF80>" + prop_GlyphIndex.intValue + "</color>"), style);
+                EditorGUI.LabelField(new Rect(rect.x, rect.y + 36, 80, 18), new GUIContent("Scale: <color=#FFFF80>" + prop_Scale.floatValue + "</color>"), style);
+
+                // Draw Glyph (if exists)
+                DrawGlyph(position, property);
+            }
+            else // Display editable fields
+            {
+                EditorGUIUtility.labelWidth = 55f;
+                GUI.SetNextControlName("Unicode Input");
+                EditorGUI.BeginChangeCheck();
+                string unicode = EditorGUI.TextField(new Rect(rect.x, rect.y, 120, 18), "Unicode:", prop_Unicode.intValue.ToString("X"));
+
+                if (GUI.GetNameOfFocusedControl() == "Unicode Input")
+                {
+                    //Filter out unwanted characters.
+                    char chr = Event.current.character;
+                    if ((chr < '0' || chr > '9') && (chr < 'a' || chr > 'f') && (chr < 'A' || chr > 'F'))
+                    {
+                        Event.current.character = '\0';
+                    }
+                }
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    // Update Unicode value
+                    prop_Unicode.intValue = TMP_TextUtilities.StringHexToInt(unicode);
+                }
+
+                // Cache current glyph index in case it needs to be restored if the new glyph index is invalid.
+                int currentGlyphIndex = prop_GlyphIndex.intValue;
+
+                EditorGUIUtility.labelWidth = 59f;
+                EditorGUI.BeginChangeCheck();
+                EditorGUI.DelayedIntField(new Rect(rect.x, rect.y + 18, 100, 18), prop_GlyphIndex, new GUIContent("Glyph ID:"));
+                if (EditorGUI.EndChangeCheck())
+                {
+                    // Get a reference to the font asset
+                    TMP_FontAsset fontAsset = property.serializedObject.targetObject as TMP_FontAsset;
+
+                    // Make sure new glyph index is valid.
+                    int elementIndex = fontAsset.glyphTable.FindIndex(item => item.index == prop_GlyphIndex.intValue);
+
+                    if (elementIndex == -1)
+                        prop_GlyphIndex.intValue = currentGlyphIndex;
+                    else
+                        fontAsset.IsFontAssetLookupTablesDirty = true;
+                }
+
+                int glyphIndex = prop_GlyphIndex.intValue;
+
+                // Reset glyph selection if new character has been selected.
+                if (GUI.enabled && m_GlyphSelectedForEditing != glyphIndex)
+                    m_GlyphSelectedForEditing = -1;
+
+                // Display button to edit the glyph data.
+                if (GUI.Button(new Rect(rect.x + 120, rect.y + 18, 75, 18), new GUIContent("Edit Glyph")))
+                {
+                    if (m_GlyphSelectedForEditing == -1)
+                        m_GlyphSelectedForEditing = glyphIndex;
+                    else
+                        m_GlyphSelectedForEditing = -1;
+
+                    // Button clicks should not result in potential change.
+                    GUI.changed = false;
+                }
+
+                // Show the glyph property drawer if selected
+                if (glyphIndex == m_GlyphSelectedForEditing && GUI.enabled)
+                {
+                    // Get a reference to the font asset
+                    TMP_FontAsset fontAsset = property.serializedObject.targetObject as TMP_FontAsset;
+
+                    if (fontAsset != null)
+                    {
+                        // Get the index of the glyph in the font asset glyph table.
+                        int elementIndex = fontAsset.glyphTable.FindIndex(item => item.index == glyphIndex);
+
+                        if (elementIndex != -1)
+                        {
+                            SerializedProperty prop_GlyphTable = property.serializedObject.FindProperty("m_GlyphTable");
+                            SerializedProperty prop_Glyph = prop_GlyphTable.GetArrayElementAtIndex(elementIndex);
+
+                            SerializedProperty prop_GlyphMetrics = prop_Glyph.FindPropertyRelative("m_Metrics");
+                            SerializedProperty prop_GlyphRect = prop_Glyph.FindPropertyRelative("m_GlyphRect");
+
+                            Rect newRect = EditorGUILayout.GetControlRect(false, 115);
+                            EditorGUI.DrawRect(new Rect(newRect.x + 52, newRect.y - 20, newRect.width - 52, newRect.height - 5), new Color(0.1f, 0.1f, 0.1f, 0.45f));
+                            EditorGUI.DrawRect(new Rect(newRect.x + 53, newRect.y - 19, newRect.width - 54, newRect.height - 7), new Color(0.3f, 0.3f, 0.3f, 0.8f));
+
+                            // Display GlyphRect
+                            newRect.x += 55;
+                            newRect.y -= 18;
+                            newRect.width += 5;
+                            EditorGUI.PropertyField(newRect, prop_GlyphRect);
+
+                            // Display GlyphMetrics
+                            newRect.y += 45;
+                            EditorGUI.PropertyField(newRect, prop_GlyphMetrics);
+
+                            rect.y += 120;
+                        }
+                    }
+                }
+
+                EditorGUIUtility.labelWidth = 39f;
+                EditorGUI.PropertyField(new Rect(rect.x, rect.y + 36, 80, 18), prop_Scale, new GUIContent("Scale:"));
+
+                // Draw Glyph (if exists)
+                DrawGlyph(position, property);
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return 58;
+        }
+
+        void DrawGlyph(Rect position, SerializedProperty property)
+        {
+            // Get a reference to the atlas texture
+            TMP_FontAsset fontAsset = property.serializedObject.targetObject as TMP_FontAsset;
+
+            if (fontAsset == null)
+                return;
+
+            // Get a reference to the Glyph Table
+            SerializedProperty prop_GlyphTable = property.serializedObject.FindProperty("m_GlyphTable");
+            int glyphIndex = property.FindPropertyRelative("m_GlyphIndex").intValue;
+            int elementIndex = fontAsset.glyphTable.FindIndex(item => item.index == glyphIndex);
+
+            // Return if we can't find the glyph
+            if (elementIndex == -1)
+                return;
+
+            SerializedProperty prop_Glyph = prop_GlyphTable.GetArrayElementAtIndex(elementIndex);
+
+            // Get reference to atlas texture.
+            int atlasIndex = prop_Glyph.FindPropertyRelative("m_AtlasIndex").intValue;
+            Texture2D atlasTexture = fontAsset.atlasTextures.Length > atlasIndex ? fontAsset.atlasTextures[atlasIndex] : null;
+
+            if (atlasTexture == null)
+                return;
+
+            Material mat;
+            if (((GlyphRasterModes)fontAsset.atlasRenderMode & GlyphRasterModes.RASTER_MODE_BITMAP) == GlyphRasterModes.RASTER_MODE_BITMAP)
+            {
+                mat = TMP_FontAssetEditor.internalBitmapMaterial;
+
+                if (mat == null)
+                    return;
+
+                mat.mainTexture = atlasTexture;
+                mat.SetColor(k_ColorProperty, Color.white);
+            }
+            else
+            {
+                mat = TMP_FontAssetEditor.internalSDFMaterial;
+
+                if (mat == null)
+                    return;
+
+                mat.mainTexture = atlasTexture;
+                mat.SetFloat(ShaderUtilities.ID_GradientScale, fontAsset.atlasPadding + 1);
+            }
+
+            // Draw glyph
+            Rect glyphDrawPosition = new Rect(position.x, position.y, 48, 58);
+
+            SerializedProperty glyphRectProperty = prop_Glyph.FindPropertyRelative("m_GlyphRect");
+
+            int padding = fontAsset.atlasPadding;
+
+            int glyphOriginX = glyphRectProperty.FindPropertyRelative("m_X").intValue - padding;
+            int glyphOriginY = glyphRectProperty.FindPropertyRelative("m_Y").intValue - padding;
+            int glyphWidth = glyphRectProperty.FindPropertyRelative("m_Width").intValue + padding * 2;
+            int glyphHeight = glyphRectProperty.FindPropertyRelative("m_Height").intValue + padding * 2;
+
+            float normalizedHeight = fontAsset.faceInfo.ascentLine - fontAsset.faceInfo.descentLine;
+            float scale = glyphDrawPosition.width / normalizedHeight;
+
+            // Compute the normalized texture coordinates
+            Rect texCoords = new Rect((float)glyphOriginX / atlasTexture.width, (float)glyphOriginY / atlasTexture.height, (float)glyphWidth / atlasTexture.width, (float)glyphHeight / atlasTexture.height);
+
+            if (Event.current.type == EventType.Repaint)
+            {
+                glyphDrawPosition.x += (glyphDrawPosition.width - glyphWidth * scale) / 2;
+                glyphDrawPosition.y += (glyphDrawPosition.height - glyphHeight * scale) / 2;
+                glyphDrawPosition.width = glyphWidth * scale;
+                glyphDrawPosition.height = glyphHeight * scale;
+
+                // Could switch to using the default material of the font asset which would require passing scale to the shader.
+                Graphics.DrawTexture(glyphDrawPosition, atlasTexture, texCoords, 0, 0, 0, 0, new Color(1f, 1f, 1f), mat);
+            }
+        }
+
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_CharacterPropertyDrawer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 01ada73c4792aba4c937ff5d92cce866
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_ColorGradientAssetMenu.cs

@@ -0,0 +1,50 @@
+using UnityEditor;
+using UnityEngine;
+using System.IO;
+using System.Collections;
+
+
+
+namespace TMPro.EditorUtilities
+{
+
+    public static class TMP_ColorGradientAssetMenu
+    {
+        [MenuItem("Assets/Create/TextMeshPro/Color Gradient", false, 115)]
+        public static void CreateColorGradient(MenuCommand context)
+        {
+            string filePath;
+
+            if (Selection.assetGUIDs.Length == 0)
+                filePath = "Assets/New TMP Color Gradient.asset";
+            else
+                filePath = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
+
+            if (Directory.Exists(filePath))
+            {
+                filePath += "/New TMP Color Gradient.asset";
+            }
+            else
+            {
+                filePath = Path.GetDirectoryName(filePath) + "/New TMP Color Gradient.asset";
+            }
+
+            filePath = AssetDatabase.GenerateUniqueAssetPath(filePath);
+
+            // Create new Color Gradient Asset.
+            TMP_ColorGradient colorGradient = ScriptableObject.CreateInstance<TMP_ColorGradient>();
+
+            // Create Asset
+            AssetDatabase.CreateAsset(colorGradient, filePath);
+
+            //EditorUtility.SetDirty(colorGradient);
+
+            AssetDatabase.SaveAssets();
+
+            AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(colorGradient));
+
+            EditorUtility.FocusProjectWindow();
+            EditorGUIUtility.PingObject(colorGradient);
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_ColorGradientAssetMenu.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d9647b571c5e44729b71d756b3d55317
+timeCreated: 1468187791
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_ColorGradientEditor.cs

@@ -0,0 +1,146 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+
+namespace TMPro.EditorUtilities
+{
+    [CustomEditor(typeof(TMP_ColorGradient))]
+    public class TMP_ColorGradientEditor : Editor
+    {
+        SerializedProperty m_ColorMode;
+        SerializedProperty m_TopLeftColor;
+        SerializedProperty m_TopRightColor;
+        SerializedProperty m_BottomLeftColor;
+        SerializedProperty m_BottomRightColor;
+
+        void OnEnable()
+        {
+            m_ColorMode = serializedObject.FindProperty("colorMode");
+            m_TopLeftColor = serializedObject.FindProperty("topLeft");
+            m_TopRightColor = serializedObject.FindProperty("topRight");
+            m_BottomLeftColor = serializedObject.FindProperty("bottomLeft");
+            m_BottomRightColor = serializedObject.FindProperty("bottomRight");
+        }
+        
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_ColorMode, new GUIContent("Color Mode"));
+            if (EditorGUI.EndChangeCheck())
+            {
+                switch ((ColorMode)m_ColorMode.enumValueIndex)
+                {
+                    case ColorMode.Single:
+                        m_TopRightColor.colorValue = m_TopLeftColor.colorValue;
+                        m_BottomLeftColor.colorValue = m_TopLeftColor.colorValue;
+                        m_BottomRightColor.colorValue = m_TopLeftColor.colorValue;
+                        break;
+                    case ColorMode.HorizontalGradient:
+                        m_BottomLeftColor.colorValue = m_TopLeftColor.colorValue;
+                        m_BottomRightColor.colorValue = m_TopRightColor.colorValue;
+                        break;
+                    case ColorMode.VerticalGradient:
+                        m_TopRightColor.colorValue = m_TopLeftColor.colorValue;
+                        m_BottomRightColor.colorValue = m_BottomLeftColor.colorValue;
+                        break;
+                }
+            }
+            Rect rect;
+            switch ((ColorMode)m_ColorMode.enumValueIndex)
+            {
+                case ColorMode.Single:
+                    EditorGUI.BeginChangeCheck();
+                    rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+                    EditorGUI.PrefixLabel(rect, new GUIContent("Colors"));
+                    rect.x += EditorGUIUtility.labelWidth;
+                    rect.width = (rect.width - EditorGUIUtility.labelWidth) / (EditorGUIUtility.wideMode ? 1f : 2f);
+                    TMP_EditorUtility.DrawColorProperty(rect, m_TopLeftColor);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_TopRightColor.colorValue = m_TopLeftColor.colorValue;
+                        m_BottomLeftColor.colorValue = m_TopLeftColor.colorValue;
+                        m_BottomRightColor.colorValue = m_TopLeftColor.colorValue;
+                    }
+                    break;
+
+                case ColorMode.HorizontalGradient:
+                    rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+                    EditorGUI.PrefixLabel(rect, new GUIContent("Colors"));
+                    rect.x += EditorGUIUtility.labelWidth;
+                    rect.width = (rect.width - EditorGUIUtility.labelWidth) / 2f;
+
+                    EditorGUI.BeginChangeCheck();
+                    TMP_EditorUtility.DrawColorProperty(rect, m_TopLeftColor);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_BottomLeftColor.colorValue = m_TopLeftColor.colorValue;
+                    }
+
+                    rect.x += rect.width;
+
+                    EditorGUI.BeginChangeCheck();
+                    TMP_EditorUtility.DrawColorProperty(rect, m_TopRightColor);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_BottomRightColor.colorValue = m_TopRightColor.colorValue;
+                    }
+                    break;
+
+                case ColorMode.VerticalGradient:
+                    rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+                    EditorGUI.PrefixLabel(rect, new GUIContent("Colors"));
+                    rect.x += EditorGUIUtility.labelWidth;
+                    rect.width = (rect.width - EditorGUIUtility.labelWidth) / (EditorGUIUtility.wideMode ? 1f : 2f);
+                    rect.height = EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2);
+
+                    EditorGUI.BeginChangeCheck();
+                    TMP_EditorUtility.DrawColorProperty(rect, m_TopLeftColor);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_TopRightColor.colorValue = m_TopLeftColor.colorValue;
+                    }
+
+                    rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+                    rect.x += EditorGUIUtility.labelWidth;
+                    rect.width = (rect.width - EditorGUIUtility.labelWidth) / (EditorGUIUtility.wideMode ? 1f : 2f);
+                    rect.height = EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2);
+
+                    EditorGUI.BeginChangeCheck();
+                    TMP_EditorUtility.DrawColorProperty(rect, m_BottomLeftColor);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        m_BottomRightColor.colorValue = m_BottomLeftColor.colorValue;
+                    }
+                    break;
+
+                case ColorMode.FourCornersGradient:
+                    rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+                    EditorGUI.PrefixLabel(rect, new GUIContent("Colors"));
+                    rect.x += EditorGUIUtility.labelWidth;
+                    rect.width = (rect.width - EditorGUIUtility.labelWidth)  / 2f;
+                    rect.height = EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2);
+                    
+                    TMP_EditorUtility.DrawColorProperty(rect, m_TopLeftColor);
+                    rect.x += rect.width;
+                    TMP_EditorUtility.DrawColorProperty(rect, m_TopRightColor);
+
+                    rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2));
+                    rect.x += EditorGUIUtility.labelWidth;
+                    rect.width = (rect.width - EditorGUIUtility.labelWidth) / 2f;
+                    rect.height = EditorGUIUtility.singleLineHeight * (EditorGUIUtility.wideMode ? 1 : 2);
+
+                    TMP_EditorUtility.DrawColorProperty(rect, m_BottomLeftColor);
+                    rect.x += rect.width;
+                    TMP_EditorUtility.DrawColorProperty(rect, m_BottomRightColor);
+                    break;
+            }
+
+            if (serializedObject.ApplyModifiedProperties())
+                TMPro_EventManager.ON_COLOR_GRADIENT_PROPERTY_CHANGED(target as TMP_ColorGradient);
+
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_ColorGradientEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fcc60c1d6bb544d9b712b652f418ff3a
+timeCreated: 1468400050
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_DropdownEditor.cs

@@ -0,0 +1,57 @@
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.UI;
+using UnityEngine.UI;
+
+namespace TMPro.EditorUtilities
+{
+    [CustomEditor(typeof(TMP_Dropdown), true)]
+    [CanEditMultipleObjects]
+    public class DropdownEditor : SelectableEditor
+    {
+        SerializedProperty m_Template;
+        SerializedProperty m_CaptionText;
+        SerializedProperty m_CaptionImage;
+        SerializedProperty m_Placeholder;
+        SerializedProperty m_ItemText;
+        SerializedProperty m_ItemImage;
+        SerializedProperty m_OnSelectionChanged;
+        SerializedProperty m_Value;
+        SerializedProperty m_AlphaFadeSpeed;
+        SerializedProperty m_Options;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            m_Template = serializedObject.FindProperty("m_Template");
+            m_CaptionText = serializedObject.FindProperty("m_CaptionText");
+            m_CaptionImage = serializedObject.FindProperty("m_CaptionImage");
+            m_Placeholder = serializedObject.FindProperty("m_Placeholder");
+            m_ItemText = serializedObject.FindProperty("m_ItemText");
+            m_ItemImage = serializedObject.FindProperty("m_ItemImage");
+            m_OnSelectionChanged = serializedObject.FindProperty("m_OnValueChanged");
+            m_Value = serializedObject.FindProperty("m_Value");
+            m_AlphaFadeSpeed = serializedObject.FindProperty("m_AlphaFadeSpeed");
+            m_Options = serializedObject.FindProperty("m_Options");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+            EditorGUILayout.Space();
+
+            serializedObject.Update();
+            EditorGUILayout.PropertyField(m_Template);
+            EditorGUILayout.PropertyField(m_CaptionText);
+            EditorGUILayout.PropertyField(m_CaptionImage);
+            EditorGUILayout.PropertyField(m_Placeholder);
+            EditorGUILayout.PropertyField(m_ItemText);
+            EditorGUILayout.PropertyField(m_ItemImage);
+            EditorGUILayout.PropertyField(m_Value);
+            EditorGUILayout.PropertyField(m_AlphaFadeSpeed);
+            EditorGUILayout.PropertyField(m_Options);
+            EditorGUILayout.PropertyField(m_OnSelectionChanged);
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_DropdownEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6dbcf248c987476181a37f01a1814975
+timeCreated: 1446377461
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_EditorCoroutine.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+
+namespace TMPro.EditorUtilities
+{
+    /// <summary>
+    /// Simple implementation of coroutine working in the Unity Editor.
+    /// </summary>
+    public class TMP_EditorCoroutine
+    {
+        //private static Dictionary<int, EditorCoroutine> s_ActiveCoroutines;
+
+        readonly IEnumerator coroutine;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="routine"></param>
+        TMP_EditorCoroutine(IEnumerator routine)
+        {
+            this.coroutine = routine;
+        }
+
+
+        /// <summary>
+        /// Starts a new EditorCoroutine.
+        /// </summary>
+        /// <param name="newCoroutine">Coroutine</param>
+        /// <returns>new EditorCoroutine</returns>
+        public static TMP_EditorCoroutine StartCoroutine(IEnumerator routine)
+        {
+            TMP_EditorCoroutine coroutine = new TMP_EditorCoroutine(routine);
+            coroutine.Start();
+
+            // Add coroutine to tracking list
+            //if (s_ActiveCoroutines == null)
+            //    s_ActiveCoroutines = new Dictionary<int, EditorCoroutine>();
+
+            // Add new instance of editor coroutine to dictionary.
+            //s_ActiveCoroutines.Add(coroutine.GetHashCode(), coroutine);
+
+            return coroutine;
+        }
+
+
+        /// <summary>
+        /// Clear delegate list 
+        /// </summary>
+        //public static void StopAllEditorCoroutines()
+        //{
+        //    EditorApplication.update = null;
+        //}
+
+
+        /// <summary>
+        /// Register callback for editor updates
+        /// </summary>
+        void Start()
+        {
+            EditorApplication.update += EditorUpdate;
+        }
+
+
+        /// <summary>
+        /// Unregister callback for editor updates.
+        /// </summary>
+        public void Stop()
+        {
+            if (EditorApplication.update != null)
+                EditorApplication.update -= EditorUpdate;
+
+            //s_ActiveCoroutines.Remove(this.GetHashCode());
+        }
+ 
+
+        /// <summary>
+        /// Delegate function called on editor updates.
+        /// </summary>
+        void EditorUpdate()
+        {
+            // Stop editor coroutine if it does not continue.
+            if (coroutine.MoveNext() == false)
+                Stop();
+
+            // Process the different types of EditorCoroutines.
+            if (coroutine.Current != null)
+            {
+
+            }
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.textmeshpro@3.0.1/Scripts/Editor/TMP_EditorCoroutine.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 27a0335dab59ec542aadd6636a5b4ebd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: