Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a1f747d86c1e64cfa8b95f8d379cc866
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e0532ddf704c64fc4b3e3a26415e514e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Fonts/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Fonts/LICENSE.txt.meta

@@ -0,0 +1,4 @@
+fileFormatVersion: 2
+guid: b8784b247b090471695b945937cf5a6b
+TextScriptImporter:
+  userData: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Fonts/RobotoCondensed-Bold.ttf.meta

@@ -0,0 +1,20 @@
+fileFormatVersion: 2
+guid: b20f139c373fa4555a05cdd0036dfa44
+timeCreated: 1475687636
+licenseType: Store
+TrueTypeFontImporter:
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontNames:
+  - Roboto Condensed
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Physics2D Materials/Bouncy.physicsMaterial2D

@@ -0,0 +1,10 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!62 &6200000
+PhysicsMaterial2D:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Bouncy
+  friction: 0.4
+  bounciness: 0.75

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Physics2D Materials/Bouncy.physicsMaterial2D.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 552718e596d0e408295d5ae742cc4097
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 6200000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Presets/Pixel Perfect Cameras.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cc2fb811f43eb478497d53d76fa4e294
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Presets/Texture Importers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 110c0194d171d433fbd5794f7afd2032
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/RoboHero/Animations.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7dd4043e34931b142b971ad25d8e3747
+folderAsset: yes
+timeCreated: 1503839726
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/RoboHero/Materials.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 29d5eda56a6200742abc7eff706371ed
+folderAsset: yes
+timeCreated: 1503839726
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/RoboHero/Prefabs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4f882420f8c38475698eb7da59d91558
+folderAsset: yes
+timeCreated: 1503846850
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Rule Tiles/Scripts/Editor/RuleTileEditor.cs

@@ -0,0 +1,350 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor.Sprites;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.Networking;
+using UnityEngine.Tilemaps;
+using Object = UnityEngine.Object;
+
+namespace UnityEditor
+{
+	[CustomEditor(typeof(RuleTile))]
+	[CanEditMultipleObjects]
+	internal class RuleTileEditor : Editor
+	{
+		private const string s_XIconString = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAABoSURBVDhPnY3BDcAgDAOZhS14dP1O0x2C/LBEgiNSHvfwyZabmV0jZRUpq2zi6f0DJwdcQOEdwwDLypF0zHLMa9+NQRxkQ+ACOT2STVw/q8eY1346ZlE54sYAhVhSDrjwFymrSFnD2gTZpls2OvFUHAAAAABJRU5ErkJggg==";
+		private const string s_Arrow0 = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAACYSURBVDhPzZExDoQwDATzE4oU4QXXcgUFj+YxtETwgpMwXuFcwMFSRMVKKwzZcWzhiMg91jtg34XIntkre5EaT7yjjhI9pOD5Mw5k2X/DdUwFr3cQ7Pu23E/BiwXyWSOxrNqx+ewnsayam5OLBtbOGPUM/r93YZL4/dhpR/amwByGFBz170gNChA6w5bQQMqramBTgJ+Z3A58WuWejPCaHQAAAABJRU5ErkJggg==";
+		private const string s_Arrow1 = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAABqSURBVDhPxYzBDYAgEATpxYcd+PVr0fZ2siZrjmMhFz6STIiDs8XMlpEyi5RkO/d66TcgJUB43JfNBqRkSEYDnYjhbKD5GIUkDqRDwoH3+NgTAw+bL/aoOP4DOgH+iwECEt+IlFmkzGHlAYKAWF9R8zUnAAAAAElFTkSuQmCC";
+		private const string s_Arrow2 = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAAC0SURBVDhPjVE5EsIwDMxPKFKYF9CagoJH8xhaMskLmEGsjOSRkBzYmU2s9a58TUQUmCH1BWEHweuKP+D8tphrWcAHuIGrjPnPNY8X2+DzEWE+FzrdrkNyg2YGNNfRGlyOaZDJOxBrDhgOowaYW8UW0Vau5ZkFmXbbDr+CzOHKmLinAXMEePyZ9dZkZR+s5QX2O8DY3zZ/sgYcdDqeEVp8516o0QQV1qeMwg6C91toYoLoo+kNt/tpKQEVvFQAAAAASUVORK5CYII=";
+		private const string s_Arrow3 = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAAB2SURBVDhPzY1LCoAwEEPnLi48gW5d6p31bH5SMhp0Cq0g+CCLxrzRPqMZ2pRqKG4IqzJc7JepTlbRZXYpWTg4RZE1XAso8VHFKNhQuTjKtZvHUNCEMogO4K3BhvMn9wP4EzoPZ3n0AGTW5fiBVzLAAYTP32C2Ay3agtu9V/9PAAAAAElFTkSuQmCC";
+		private const string s_Arrow5 = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAABqSURBVDhPnY3BCYBADASvFx924NevRdvbyoLBmNuDJQMDGjNxAFhK1DyUQ9fvobCdO+j7+sOKj/uSB+xYHZAxl7IR1wNTXJeVcaAVU+614uWfCT9mVUhknMlxDokd15BYsQrJFHeUQ0+MB5ErsPi/6hO1AAAAAElFTkSuQmCC";
+		private const string s_Arrow6 = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAACaSURBVDhPxZExEkAwEEVzE4UiTqClUDi0w2hlOIEZsV82xCZmQuPPfFn8t1mirLWf7S5flQOXjd64vCuEKWTKVt+6AayH3tIa7yLg6Qh2FcKFB72jBgJeziA1CMHzeaNHjkfwnAK86f3KUafU2ClHIJSzs/8HHLv09M3SaMCxS7ljw/IYJWzQABOQZ66x4h614ahTCL/WT7BSO51b5Z5hSx88AAAAAElFTkSuQmCC";
+		private const string s_Arrow7 = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAABQSURBVDhPYxh8QNle/T8U/4MKEQdAmsz2eICx6W530gygr2aQBmSMphkZYxqErAEXxusKfAYQ7XyyNMIAsgEkaYQBkAFkaYQBsjXSGDAwAAD193z4luKPrAAAAABJRU5ErkJggg==";
+		private const string s_Arrow8 = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuNWWFMmUAAACYSURBVDhPxZE9DoAwCIW9iUOHegJXHRw8tIdx1egJTMSHAeMPaHSR5KVQ+KCkCRF91mdz4VDEWVzXTBgg5U1N5wahjHzXS3iFFVRxAygNVaZxJ6VHGIl2D6oUXP0ijlJuTp724FnID1Lq7uw2QM5+thoKth0N+GGyA7IA3+yM77Ag1e2zkey5gCdAg/h8csy+/89v7E+YkgUntOWeVt2SfAAAAABJRU5ErkJggg==";
+		private const string s_MirrorX = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwQAADsEBuJFr7QAAABh0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC41ZYUyZQAAAG1JREFUOE+lj9ENwCAIRB2IFdyRfRiuDSaXAF4MrR9P5eRhHGb2Gxp2oaEjIovTXSrAnPNx6hlgyCZ7o6omOdYOldGIZhAziEmOTSfigLV0RYAB9y9f/7kO8L3WUaQyhCgz0dmCL9CwCw172HgBeyG6oloC8fAAAAAASUVORK5CYII=";
+		private const string s_MirrorY = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwgAADsIBFShKgAAAABh0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC41ZYUyZQAAAG9JREFUOE+djckNACEMAykoLdAjHbPyw1IOJ0L7mAejjFlm9hspyd77Kk+kBAjPOXcakJIh6QaKyOE0EB5dSPJAiUmOiL8PMVGxugsP/0OOib8vsY8yYwy6gRyC8CB5QIWgCMKBLgRSkikEUr5h6wOPWfMoCYILdgAAAABJRU5ErkJggg==";
+		private const string s_Rotated = "iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwQAADsEBuJFr7QAAABh0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC41ZYUyZQAAAHdJREFUOE+djssNwCAMQxmIFdgx+2S4Vj4YxWlQgcOT8nuG5u5C732Sd3lfLlmPMR4QhXgrTQaimUlA3EtD+CJlBuQ7aUAUMjEAv9gWCQNEPhHJUkYfZ1kEpcxDzioRzGIlr0Qwi0r+Q5rTgM+AAVcygHgt7+HtBZs/2QVWP8ahAAAAAElFTkSuQmCC";
+		
+		private static Texture2D[] s_Arrows;
+		public static Texture2D[] arrows
+		{
+			get
+			{
+				if (s_Arrows == null)
+				{
+					s_Arrows = new Texture2D[10];
+					s_Arrows[0] = Base64ToTexture(s_Arrow0);
+					s_Arrows[1] = Base64ToTexture(s_Arrow1);
+					s_Arrows[2] = Base64ToTexture(s_Arrow2);
+					s_Arrows[3] = Base64ToTexture(s_Arrow3);
+					s_Arrows[5] = Base64ToTexture(s_Arrow5);
+					s_Arrows[6] = Base64ToTexture(s_Arrow6);
+					s_Arrows[7] = Base64ToTexture(s_Arrow7);
+					s_Arrows[8] = Base64ToTexture(s_Arrow8);
+					s_Arrows[9] = Base64ToTexture(s_XIconString);
+				}
+				return s_Arrows;
+			}
+		}
+
+		private static Texture2D[] s_AutoTransforms;
+		public static Texture2D[] autoTransforms
+		{
+			get
+			{
+				if (s_AutoTransforms == null)
+				{
+					s_AutoTransforms = new Texture2D[3];
+					s_AutoTransforms[0] = Base64ToTexture(s_Rotated);
+					s_AutoTransforms[1] = Base64ToTexture(s_MirrorX);
+					s_AutoTransforms[2] = Base64ToTexture(s_MirrorY);
+				}
+				return s_AutoTransforms;
+			}
+		}
+		
+		private ReorderableList m_ReorderableList;
+		public RuleTile tile { get { return (target as RuleTile); } }
+		private Rect m_ListRect;
+
+		const float k_DefaultElementHeight = 48f;
+		const float k_PaddingBetweenRules = 13f;
+		const float k_SingleLineHeight = 16f;
+		const float k_LabelWidth = 53f;
+			
+		public void OnEnable()
+		{
+			if (tile.m_TilingRules == null)
+				tile.m_TilingRules = new List<RuleTile.TilingRule>();
+
+			m_ReorderableList = new ReorderableList(tile.m_TilingRules, typeof(RuleTile.TilingRule), true, true, true, true);
+			m_ReorderableList.drawHeaderCallback = OnDrawHeader;
+			m_ReorderableList.drawElementCallback = OnDrawElement;
+			m_ReorderableList.elementHeightCallback = GetElementHeight;
+			m_ReorderableList.onReorderCallback = ListUpdated;
+		}
+
+		private void ListUpdated(ReorderableList list)
+		{
+			SaveTile();
+		}
+
+		private float GetElementHeight(int index)
+		{
+			if (tile.m_TilingRules != null && tile.m_TilingRules.Count > 0)
+			{
+				switch (tile.m_TilingRules[index].m_Output)
+				{
+					case RuleTile.TilingRule.OutputSprite.Random:
+						return k_DefaultElementHeight + k_SingleLineHeight*(tile.m_TilingRules[index].m_Sprites.Length + 3) + k_PaddingBetweenRules;
+					case RuleTile.TilingRule.OutputSprite.Animation:
+						return k_DefaultElementHeight + k_SingleLineHeight*(tile.m_TilingRules[index].m_Sprites.Length + 2) + k_PaddingBetweenRules;
+				}
+			}
+			return k_DefaultElementHeight + k_PaddingBetweenRules;
+		}
+
+		private void OnDrawElement(Rect rect, int index, bool isactive, bool isfocused)
+		{
+			RuleTile.TilingRule rule = tile.m_TilingRules[index];
+
+			float yPos = rect.yMin + 2f;
+			float height = rect.height - k_PaddingBetweenRules;
+			float matrixWidth = k_DefaultElementHeight;
+			
+			Rect inspectorRect = new Rect(rect.xMin, yPos, rect.width - matrixWidth * 2f - 20f, height);
+			Rect matrixRect = new Rect(rect.xMax - matrixWidth * 2f - 10f, yPos, matrixWidth, k_DefaultElementHeight);
+			Rect spriteRect = new Rect(rect.xMax - matrixWidth - 5f, yPos, matrixWidth, k_DefaultElementHeight);
+
+			EditorGUI.BeginChangeCheck();
+			RuleInspectorOnGUI(inspectorRect, rule);
+			RuleMatrixOnGUI(matrixRect, rule);
+			SpriteOnGUI(spriteRect, rule);
+			if (EditorGUI.EndChangeCheck())
+				SaveTile();
+		}
+
+		private void SaveTile()
+		{
+			EditorUtility.SetDirty(target);
+			SceneView.RepaintAll();
+		}
+
+		private void OnDrawHeader(Rect rect)
+		{
+			GUI.Label(rect, "Tiling Rules");
+		}
+
+		public override void OnInspectorGUI()
+		{
+			tile.m_DefaultSprite = EditorGUILayout.ObjectField("Default Sprite", tile.m_DefaultSprite, typeof(Sprite), false) as Sprite;
+			tile.m_DefaultColliderType = (Tile.ColliderType)EditorGUILayout.EnumPopup("Default Collider", tile.m_DefaultColliderType);
+			EditorGUILayout.Space();
+
+			if (m_ReorderableList != null && tile.m_TilingRules != null)
+				m_ReorderableList.DoLayoutList();
+		}
+
+		private static void RuleMatrixOnGUI(Rect rect, RuleTile.TilingRule tilingRule)
+		{
+			Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
+			int index = 0;
+			float w = rect.width / 3f;
+			float h = rect.height / 3f;
+
+			for (int y = 0; y <= 3; y++)
+			{
+				float top = rect.yMin + y * h;
+				Handles.DrawLine(new Vector3(rect.xMin, top), new Vector3(rect.xMax, top));
+			}
+			for (int x = 0; x <= 3; x++)
+			{
+				float left = rect.xMin + x * w;
+				Handles.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax));
+			}
+			Handles.color = Color.white;
+
+			for (int y = 0; y <= 2; y++)
+			{
+				for (int x = 0; x <= 2; x++)
+				{
+					Rect r = new Rect(rect.xMin + x * w, rect.yMin + y * h, w - 1, h - 1);
+					if (x != 1 || y != 1)
+					{
+						switch (tilingRule.m_Neighbors[index])
+						{
+							case RuleTile.TilingRule.Neighbor.This:
+								GUI.DrawTexture(r, arrows[y*3 + x]);
+								break;
+							case RuleTile.TilingRule.Neighbor.NotThis:
+								GUI.DrawTexture(r, arrows[9]);
+								break;
+						}
+						if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
+						{
+							tilingRule.m_Neighbors[index] = (RuleTile.TilingRule.Neighbor) (((int)tilingRule.m_Neighbors[index] + 1) % 3);
+							GUI.changed = true;
+							Event.current.Use();
+						}
+
+						index++;
+					}
+					else
+					{
+						switch (tilingRule.m_RuleTransform)
+						{
+							case RuleTile.TilingRule.Transform.Rotated:
+								GUI.DrawTexture(r, autoTransforms[0]);
+								break;
+							case RuleTile.TilingRule.Transform.MirrorX:
+								GUI.DrawTexture(r, autoTransforms[1]);
+								break;
+							case RuleTile.TilingRule.Transform.MirrorY:
+								GUI.DrawTexture(r, autoTransforms[2]);
+								break;
+						}
+
+						if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
+						{
+							tilingRule.m_RuleTransform = (RuleTile.TilingRule.Transform)(((int)tilingRule.m_RuleTransform + 1) % 4);
+							GUI.changed = true;
+							Event.current.Use();
+						}
+					}
+				}
+			}
+		}
+
+		private static void OnSelect(object userdata)
+		{
+			MenuItemData data = (MenuItemData) userdata;
+			data.m_Rule.m_RuleTransform = data.m_NewValue;
+		}
+
+		private class MenuItemData
+		{
+			public RuleTile.TilingRule m_Rule;
+			public RuleTile.TilingRule.Transform m_NewValue;
+
+			public MenuItemData(RuleTile.TilingRule mRule, RuleTile.TilingRule.Transform mNewValue)
+			{
+				this.m_Rule = mRule;
+				this.m_NewValue = mNewValue;
+			}
+		}
+
+		private void SpriteOnGUI(Rect rect, RuleTile.TilingRule tilingRule)
+		{
+			tilingRule.m_Sprites[0] = EditorGUI.ObjectField(new Rect(rect.xMax - rect.height, rect.yMin, rect.height, rect.height), tilingRule.m_Sprites[0], typeof (Sprite), false) as Sprite;
+		}
+
+		private static void RuleInspectorOnGUI(Rect rect, RuleTile.TilingRule tilingRule)
+		{
+			float y = rect.yMin;
+			EditorGUI.BeginChangeCheck();
+			GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Rule");
+			tilingRule.m_RuleTransform = (RuleTile.TilingRule.Transform)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), tilingRule.m_RuleTransform);
+			y += k_SingleLineHeight;
+			GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Collider");
+			tilingRule.m_ColliderType = (Tile.ColliderType)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), tilingRule.m_ColliderType);
+			y += k_SingleLineHeight;
+			GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Output");
+			tilingRule.m_Output = (RuleTile.TilingRule.OutputSprite)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), tilingRule.m_Output);
+			y += k_SingleLineHeight;
+
+			if (tilingRule.m_Output == RuleTile.TilingRule.OutputSprite.Animation)
+			{
+				GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Speed");
+				tilingRule.m_AnimationSpeed = EditorGUI.FloatField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), tilingRule.m_AnimationSpeed);
+				y += k_SingleLineHeight;
+			}
+			if (tilingRule.m_Output == RuleTile.TilingRule.OutputSprite.Random)
+			{
+				GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Noise");
+				tilingRule.m_PerlinScale = EditorGUI.Slider(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), tilingRule.m_PerlinScale, 0.001f, 0.999f);
+				y += k_SingleLineHeight;
+
+				GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Shuffle");
+				tilingRule.m_RandomTransform = (RuleTile.TilingRule.Transform)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), tilingRule.m_RandomTransform);
+				y += k_SingleLineHeight;
+			}
+
+			if (tilingRule.m_Output != RuleTile.TilingRule.OutputSprite.Single)
+			{
+				GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Size");
+				EditorGUI.BeginChangeCheck();
+				int newLength = EditorGUI.IntField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), tilingRule.m_Sprites.Length);
+				if (EditorGUI.EndChangeCheck())
+					Array.Resize(ref tilingRule.m_Sprites, Math.Max(newLength, 1));
+				y += k_SingleLineHeight;
+
+				for (int i = 0; i < tilingRule.m_Sprites.Length; i++)
+				{
+					tilingRule.m_Sprites[i] = EditorGUI.ObjectField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), tilingRule.m_Sprites[i], typeof(Sprite), false) as Sprite;
+					y += k_SingleLineHeight;
+				}
+			}
+		}
+
+		public override Texture2D RenderStaticPreview(string assetPath, Object[] subAssets, int width, int height)
+		{
+			if (tile.m_DefaultSprite != null)
+			{
+				Type t = GetType("UnityEditor.SpriteUtility");
+				if (t != null)
+				{
+					MethodInfo method = t.GetMethod("RenderStaticPreview", new Type[] {typeof (Sprite), typeof (Color), typeof (int), typeof (int)});
+					if (method != null)
+					{
+						object ret = method.Invoke("RenderStaticPreview", new object[] {tile.m_DefaultSprite, Color.white, width, height});
+						if (ret is Texture2D)
+							return ret as Texture2D;
+					}
+				}
+			}
+			return base.RenderStaticPreview(assetPath, subAssets, width, height);
+		}
+
+		private static Type GetType(string TypeName)
+		{
+			var type = Type.GetType(TypeName);
+			if (type != null)
+				return type;
+
+			if (TypeName.Contains("."))
+			{
+				var assemblyName = TypeName.Substring(0, TypeName.IndexOf('.'));
+				var assembly = Assembly.Load(assemblyName);
+				if (assembly == null)
+					return null;
+				type = assembly.GetType(TypeName);
+				if (type != null)
+					return type;
+			}
+
+			var currentAssembly = Assembly.GetExecutingAssembly();
+			var referencedAssemblies = currentAssembly.GetReferencedAssemblies();
+			foreach (var assemblyName in referencedAssemblies)
+			{
+				var assembly = Assembly.Load(assemblyName);
+				if (assembly != null)
+				{
+					type = assembly.GetType(TypeName);
+					if (type != null)
+						return type;
+				}
+			}
+			return null;
+		}
+
+		private static Texture2D Base64ToTexture(string base64)
+		{
+			Texture2D t = new Texture2D(1, 1);
+			t.hideFlags = HideFlags.HideAndDontSave;
+			t.LoadImage(System.Convert.FromBase64String(base64));
+			return t;
+		}
+	}
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.psdimporter@4.0.2/Editor/PSDPlugin/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.2D.PsdImporter.Editor")]

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.psdimporter@4.0.2/Editor/PSDPlugin/AssemblyInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 86edfd93afbfbfd4a9dd8afefbb6ba14
+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.2d.psdimporter@4.0.2/Editor/PSDPlugin/PsdFile/Compression/ImageDataFactory.cs

@@ -0,0 +1,96 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+// Photoshop PSD FileType Plugin for Paint.NET
+// http://psdplugin.codeplex.com/
+//
+// This software is provided under the MIT License:
+//   Copyright (c) 2006-2007 Frank Blumenberg
+//   Copyright (c) 2010-2016 Tao Yue
+//
+// See LICENSE.txt for complete licensing and attribution information.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+using System;
+using System.IO.Compression;
+using PDNWrapper;
+
+namespace PhotoshopFile.Compression
+{
+    internal static class ImageDataFactory
+    {
+        /// <summary>
+        /// Creates an ImageData object to compress or decompress image data.
+        /// </summary>
+        /// <param name="channel">The Channel associated with the image data.</param>
+        /// <param name="data">The image data to be decompressed, or null if
+        ///   image data is to be compressed.</param>
+        public static ImageData Create(Channel channel, byte[] data)
+        {
+            var bitDepth = channel.Layer.PsdFile.BitDepth;
+            ImageData imageData;
+            switch (channel.ImageCompression)
+            {
+                case ImageCompression.Raw:
+                    imageData = new RawImage(data, channel.Rect.Size, bitDepth);
+                    break;
+
+                case ImageCompression.Rle:
+                    imageData = new RleImage(data, channel.RleRowLengths,
+                            channel.Rect.Size, bitDepth);
+                    break;
+
+                case ImageCompression.Zip:
+                    // Photoshop treats 32-bit Zip as 32-bit ZipPrediction
+                    imageData = (bitDepth == 32)
+                        ? CreateZipPredict(data, channel.Rect.Size, bitDepth)
+                        : new ZipImage(data, channel.Rect.Size, bitDepth);
+                    break;
+
+                case ImageCompression.ZipPrediction:
+                    imageData = CreateZipPredict(data, channel.Rect.Size, bitDepth);
+                    break;
+
+                default:
+                    throw new PsdInvalidException("Unknown image compression method.");
+            }
+
+            // Reverse endianness of multi-byte image data
+            imageData = WrapEndianness(imageData);
+
+            return imageData;
+        }
+
+        private static ImageData CreateZipPredict(byte[] data, Size size,
+            int bitDepth)
+        {
+            switch (bitDepth)
+            {
+                case 16:
+                    return new ZipPredict16Image(data, size);
+                case 32:
+                    return new ZipPredict32Image(data, size);
+                default:
+                    throw new PsdInvalidException(
+                    "ZIP with prediction is only available for 16 and 32 bit depths.");
+            }
+        }
+
+        private static ImageData WrapEndianness(ImageData imageData)
+        {
+            // Single-byte image does not require endianness reversal
+            if (imageData.BitDepth <= 8)
+            {
+                return imageData;
+            }
+
+            // Bytes will be reordered by the compressor, so no wrapper is needed
+            if ((imageData is ZipPredict16Image) || (imageData is ZipPredict32Image))
+            {
+                return imageData;
+            }
+
+            return new EndianReverser(imageData);
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.psdimporter@4.0.2/Tests/EditorTests/PlaceholderTests.cs

@@ -0,0 +1,14 @@
+using NUnit.Framework;
+
+namespace UnityEditor.Experimental.U2D.PSDImporter.Tests
+{
+    internal class Placeholder
+    {
+        [Test]
+        public void PlaceHolderTest()
+        {
+            // Use the Assert class to test conditions.
+            Assert.Pass("This is a placeholder to ensure we have at least one test.");
+        }
+    }
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.psdimporter@4.0.2/Tests/EditorTests/PlaceholderTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e02c5dbafeee6ae488b1efd88793f456
+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.2d.psdimporter@4.0.2/Tests/EditorTests/Unity.2D.Psdimporter.EditorTests.asmdef

@@ -0,0 +1,25 @@
+{
+    "name": "Unity.2D.Psdimporter.EditorTests",
+    "references": [
+        "Unity.2D.Common.Editor",
+        "Unity.2D.Psdimporter.Editor",
+        "Unity.2D.Animation.Editor",
+        "Unity.2D.Animation.Runtime",
+        "Unity.2D.Sprite.Editor"
+    ],
+    "optionalUnityReferences": [
+        "TestAssemblies"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": []
+}

benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.psdimporter@4.0.2/Tests/EditorTests/Unity.2D.Psdimporter.EditorTests.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 782c623a3cbd6d940be3a3bcf0d4604b
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: