text:
//this source code was auto-generated by tolua#, do not modify it
using System;
using LuaInterface;

public class System_Collections_Generic_List_UnityEngine_UILineInfoWrap
{
	public static void Register(LuaState L)
	{
		L.BeginClass(typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>), typeof(System.Object), "List_UnityEngine_UILineInfo");
		L.RegFunction("Add", Add);
		L.RegFunction("AddRange", AddRange);
		L.RegFunction("AsReadOnly", AsReadOnly);
		L.RegFunction("BinarySearch", BinarySearch);
		L.RegFunction("Clear", Clear);
		L.RegFunction("Contains", Contains);
		L.RegFunction("CopyTo", CopyTo);
		L.RegFunction("Exists", Exists);
		L.RegFunction("Find", Find);
		L.RegFunction("FindAll", FindAll);
		L.RegFunction("FindIndex", FindIndex);
		L.RegFunction("FindLast", FindLast);
		L.RegFunction("FindLastIndex", FindLastIndex);
		L.RegFunction("ForEach", ForEach);
		L.RegFunction("GetEnumerator", GetEnumerator);
		L.RegFunction("GetRange", GetRange);
		L.RegFunction("IndexOf", IndexOf);
		L.RegFunction("Insert", Insert);
		L.RegFunction("InsertRange", InsertRange);
		L.RegFunction("LastIndexOf", LastIndexOf);
		L.RegFunction("Remove", Remove);
		L.RegFunction("RemoveAll", RemoveAll);
		L.RegFunction("RemoveAt", RemoveAt);
		L.RegFunction("RemoveRange", RemoveRange);
		L.RegFunction("Reverse", Reverse);
		L.RegFunction("Sort", Sort);
		L.RegFunction("ToArray", ToArray);
		L.RegFunction("TrimExcess", TrimExcess);
		L.RegFunction("TrueForAll", TrueForAll);
		L.RegFunction(".geti", get_Item);
		L.RegFunction("get_Item", get_Item);
		L.RegFunction(".seti", set_Item);
		L.RegFunction("set_Item", set_Item);
		L.RegFunction("New", _CreateSystem_Collections_Generic_List_UnityEngine_UILineInfo);
		L.RegVar("this", _this, null);
		L.RegFunction("__tostring", ToLua.op_ToString);
		L.RegVar("Capacity", get_Capacity, set_Capacity);
		L.RegVar("Count", get_Count, null);
		L.EndClass();
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int _CreateSystem_Collections_Generic_List_UnityEngine_UILineInfo(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 0)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = new System.Collections.Generic.List<UnityEngine.UILineInfo>();
				ToLua.PushSealed(L, obj);
				return 1;
			}
			else if (count == 1 && TypeChecker.CheckTypes<int>(L, 1))
			{
				int arg0 = (int)LuaDLL.lua_tonumber(L, 1);
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = new System.Collections.Generic.List<UnityEngine.UILineInfo>(arg0);
				ToLua.PushSealed(L, obj);
				return 1;
			}
			else if (count == 1 && TypeChecker.CheckTypes<System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo>>(L, 1))
			{
				System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo> arg0 = (System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo>)ToLua.ToObject(L, 1);
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = new System.Collections.Generic.List<UnityEngine.UILineInfo>(arg0);
				ToLua.PushSealed(L, obj);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to ctor method: System.Collections.Generic.List<UnityEngine.UILineInfo>.New");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int _get_this(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			UnityEngine.UILineInfo o = obj[arg0];
			ToLua.PushValue(L, o);
			return 1;

		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int _set_this(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			UnityEngine.UILineInfo arg1 = StackTraits<UnityEngine.UILineInfo>.Check(L, 3);
			obj[arg0] = arg1;
			return 0;

		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int _this(IntPtr L)
	{
		try
		{
			LuaDLL.lua_pushvalue(L, 1);
			LuaDLL.tolua_bindthis(L, _get_this, _set_this);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Add(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
			obj.Add(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int AddRange(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo> arg0 = (System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo>)ToLua.CheckObject<System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo>>(L, 2);
			obj.AddRange(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int AsReadOnly(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Collections.ObjectModel.ReadOnlyCollection<UnityEngine.UILineInfo> o = obj.AsReadOnly();
			ToLua.PushObject(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int BinarySearch(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 2)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
				int o = obj.BinarySearch(arg0);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 3)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
				System.Collections.Generic.IComparer<UnityEngine.UILineInfo> arg1 = (System.Collections.Generic.IComparer<UnityEngine.UILineInfo>)ToLua.CheckObject<System.Collections.Generic.IComparer<UnityEngine.UILineInfo>>(L, 3);
				int o = obj.BinarySearch(arg0, arg1);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 5)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				UnityEngine.UILineInfo arg2 = StackTraits<UnityEngine.UILineInfo>.Check(L, 4);
				System.Collections.Generic.IComparer<UnityEngine.UILineInfo> arg3 = (System.Collections.Generic.IComparer<UnityEngine.UILineInfo>)ToLua.CheckObject<System.Collections.Generic.IComparer<UnityEngine.UILineInfo>>(L, 5);
				int o = obj.BinarySearch(arg0, arg1, arg2, arg3);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: System.Collections.Generic.List<UnityEngine.UILineInfo>.BinarySearch");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Clear(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			obj.Clear();
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Contains(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
			bool o = obj.Contains(arg0);
			LuaDLL.lua_pushboolean(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CopyTo(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 2)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo[] arg0 = ToLua.CheckStructArray<UnityEngine.UILineInfo>(L, 2);
				obj.CopyTo(arg0);
				return 0;
			}
			else if (count == 3)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo[] arg0 = ToLua.CheckStructArray<UnityEngine.UILineInfo>(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				obj.CopyTo(arg0, arg1);
				return 0;
			}
			else if (count == 5)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				UnityEngine.UILineInfo[] arg1 = ToLua.CheckStructArray<UnityEngine.UILineInfo>(L, 3);
				int arg2 = (int)LuaDLL.luaL_checknumber(L, 4);
				int arg3 = (int)LuaDLL.luaL_checknumber(L, 5);
				obj.CopyTo(arg0, arg1, arg2, arg3);
				return 0;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: System.Collections.Generic.List<UnityEngine.UILineInfo>.CopyTo");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Exists(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Predicate<UnityEngine.UILineInfo> arg0 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 2);
			bool o = obj.Exists(arg0);
			LuaDLL.lua_pushboolean(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Find(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Predicate<UnityEngine.UILineInfo> arg0 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 2);
			UnityEngine.UILineInfo o = obj.Find(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int FindAll(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Predicate<UnityEngine.UILineInfo> arg0 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> o = obj.FindAll(arg0);
			ToLua.PushSealed(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int FindIndex(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 2)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				System.Predicate<UnityEngine.UILineInfo> arg0 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 2);
				int o = obj.FindIndex(arg0);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 3)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				System.Predicate<UnityEngine.UILineInfo> arg1 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 3);
				int o = obj.FindIndex(arg0, arg1);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 4)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				System.Predicate<UnityEngine.UILineInfo> arg2 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 4);
				int o = obj.FindIndex(arg0, arg1, arg2);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: System.Collections.Generic.List<UnityEngine.UILineInfo>.FindIndex");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int FindLast(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Predicate<UnityEngine.UILineInfo> arg0 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 2);
			UnityEngine.UILineInfo o = obj.FindLast(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int FindLastIndex(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 2)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				System.Predicate<UnityEngine.UILineInfo> arg0 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 2);
				int o = obj.FindLastIndex(arg0);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 3)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				System.Predicate<UnityEngine.UILineInfo> arg1 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 3);
				int o = obj.FindLastIndex(arg0, arg1);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 4)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				System.Predicate<UnityEngine.UILineInfo> arg2 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 4);
				int o = obj.FindLastIndex(arg0, arg1, arg2);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: System.Collections.Generic.List<UnityEngine.UILineInfo>.FindLastIndex");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ForEach(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Action<UnityEngine.UILineInfo> arg0 = (System.Action<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Action<UnityEngine.UILineInfo>>(L, 2);
			obj.ForEach(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetEnumerator(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Collections.IEnumerator o = obj.GetEnumerator();
			ToLua.Push(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetRange(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
			System.Collections.Generic.List<UnityEngine.UILineInfo> o = obj.GetRange(arg0, arg1);
			ToLua.PushSealed(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int IndexOf(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 2)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
				int o = obj.IndexOf(arg0);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 3)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				int o = obj.IndexOf(arg0, arg1);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 4)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				int arg2 = (int)LuaDLL.luaL_checknumber(L, 4);
				int o = obj.IndexOf(arg0, arg1, arg2);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: System.Collections.Generic.List<UnityEngine.UILineInfo>.IndexOf");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Insert(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			UnityEngine.UILineInfo arg1 = StackTraits<UnityEngine.UILineInfo>.Check(L, 3);
			obj.Insert(arg0, arg1);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int InsertRange(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo> arg1 = (System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo>)ToLua.CheckObject<System.Collections.Generic.IEnumerable<UnityEngine.UILineInfo>>(L, 3);
			obj.InsertRange(arg0, arg1);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int LastIndexOf(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 2)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
				int o = obj.LastIndexOf(arg0);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 3)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				int o = obj.LastIndexOf(arg0, arg1);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else if (count == 4)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				int arg2 = (int)LuaDLL.luaL_checknumber(L, 4);
				int o = obj.LastIndexOf(arg0, arg1, arg2);
				LuaDLL.lua_pushinteger(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: System.Collections.Generic.List<UnityEngine.UILineInfo>.LastIndexOf");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Remove(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			UnityEngine.UILineInfo arg0 = StackTraits<UnityEngine.UILineInfo>.Check(L, 2);
			bool o = obj.Remove(arg0);
			LuaDLL.lua_pushboolean(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int RemoveAll(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Predicate<UnityEngine.UILineInfo> arg0 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 2);
			int o = obj.RemoveAll(arg0);
			LuaDLL.lua_pushinteger(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int RemoveAt(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.RemoveAt(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int RemoveRange(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
			obj.RemoveRange(arg0, arg1);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Reverse(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 1)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				obj.Reverse();
				return 0;
			}
			else if (count == 3)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				obj.Reverse(arg0, arg1);
				return 0;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: System.Collections.Generic.List<UnityEngine.UILineInfo>.Reverse");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Sort(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 1)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				obj.Sort();
				return 0;
			}
			else if (count == 2 && TypeChecker.CheckTypes<System.Comparison<UnityEngine.UILineInfo>>(L, 2))
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				System.Comparison<UnityEngine.UILineInfo> arg0 = (System.Comparison<UnityEngine.UILineInfo>)ToLua.ToObject(L, 2);
				obj.Sort(arg0);
				return 0;
			}
			else if (count == 2 && TypeChecker.CheckTypes<System.Collections.Generic.IComparer<UnityEngine.UILineInfo>>(L, 2))
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				System.Collections.Generic.IComparer<UnityEngine.UILineInfo> arg0 = (System.Collections.Generic.IComparer<UnityEngine.UILineInfo>)ToLua.ToObject(L, 2);
				obj.Sort(arg0);
				return 0;
			}
			else if (count == 4)
			{
				System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
				System.Collections.Generic.IComparer<UnityEngine.UILineInfo> arg2 = (System.Collections.Generic.IComparer<UnityEngine.UILineInfo>)ToLua.CheckObject<System.Collections.Generic.IComparer<UnityEngine.UILineInfo>>(L, 4);
				obj.Sort(arg0, arg1, arg2);
				return 0;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: System.Collections.Generic.List<UnityEngine.UILineInfo>.Sort");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ToArray(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			UnityEngine.UILineInfo[] o = obj.ToArray();
			ToLua.Push(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int TrimExcess(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			obj.TrimExcess();
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int TrueForAll(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			System.Predicate<UnityEngine.UILineInfo> arg0 = (System.Predicate<UnityEngine.UILineInfo>)ToLua.CheckDelegate<System.Predicate<UnityEngine.UILineInfo>>(L, 2);
			bool o = obj.TrueForAll(arg0);
			LuaDLL.lua_pushboolean(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Item(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			UnityEngine.UILineInfo o = obj[arg0];
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_Item(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)ToLua.CheckObject(L, 1, typeof(System.Collections.Generic.List<UnityEngine.UILineInfo>));
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			UnityEngine.UILineInfo arg1 = StackTraits<UnityEngine.UILineInfo>.Check(L, 3);
			obj[arg0] = arg1;
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Capacity(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)o;
			int ret = obj.Capacity;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Capacity on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Count(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)o;
			int ret = obj.Count;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Count on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_Capacity(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			System.Collections.Generic.List<UnityEngine.UILineInfo> obj = (System.Collections.Generic.List<UnityEngine.UILineInfo>)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.Capacity = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Capacity on a nil value");
		}
	}
}


text:
chrome.runtime.onSuspend.addListener(function() {
  var now = new Date();
  chrome.storage.local.set({"last_save": now.toLocaleString()}, function() {
    console.log("Finished writing last_save: " + now.toLocaleString());
  });
});

redpajama_set_name: RedPajamaGithub


text:
package hermes.network.packets;

/**
 *
 * @author Rolando Martins <rolandomartins@cmu.edu>
 */
public interface HermesNetworkOperations {
    public static final int GET_ID = 0x1;
}


text:
package com.material.am.dialogplus;

import android.view.animation.Animation;

/**
 * @author Orhan Obut
 */
public class SimpleAnimationListener implements Animation.AnimationListener {
  @Override
  public void onAnimationStart(Animation animation) {

  }

  @Override
  public void onAnimationEnd(Animation animation) {

  }

  @Override
  public void onAnimationRepeat(Animation animation) {

  }
}


text:
package me.itszooti.geojson.jts;

import me.itszooti.geojson.GeoGeometry;
import me.itszooti.geojson.GeoLineString;
import me.itszooti.geojson.GeoPoint;
import me.itszooti.geojson.GeoPolygon;
import me.itszooti.geojson.GeoPosition;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;
import com.vividsolutions.jts.geom.LineString;
import com.vividsolutions.jts.geom.LinearRing;
import com.vividsolutions.jts.geom.Point;
import com.vividsolutions.jts.geom.Polygon;

public class GeoJtsConverter {

	private GeometryFactory geomFactory;

	public GeoJtsConverter() {
		geomFactory = new GeometryFactory();
	}

	public GeoGeometry fromJts(Geometry geom) {
		GeoGeometry geoGeom = null;

		// check type and convert
		if (geom instanceof Point) {
			geoGeom = fromJtsPoint((Point)geom);
		} else if (geom instanceof LineString) {
			geoGeom = fromJtsLineString((LineString)geom);
		} else if (geom instanceof Polygon) {
			geoGeom = fromJtsPolygon((Polygon)geom);
		} else {
			throw new IllegalArgumentException("Unsupported JTS Geometry type: " + geom.getClass().getSimpleName());
		}

		return geoGeom;
	}

	private GeoPoint fromJtsPoint(Point point) {
		GeoPosition pos = new GeoPosition(point.getX(), point.getY());
		return new GeoPoint(pos);
	}

	private GeoLineString fromJtsLineString(LineString lineString) {
		GeoPosition[] positions = toPositionsArray(lineString.getCoordinates());
		return new GeoLineString(positions);
	}

	private GeoPolygon fromJtsPolygon(Polygon polygon) {
		GeoPosition[] exterior = toPositionsArray(polygon.getExteriorRing().getCoordinates());
		int numInteriors = polygon.getNumInteriorRing();
		GeoPosition[][] interiors = new GeoPosition[numInteriors][];
		for (int i = 0; i < numInteriors; i++) {
			interiors[i] = toPositionsArray(polygon.getInteriorRingN(i).getCoordinates());
		}
		return new GeoPolygon(exterior, interiors);
	}

	private GeoPosition[] toPositionsArray(Coordinate[] coordinateArray) {
		GeoPosition[] positions = new GeoPosition[coordinateArray.length];
		for (int i = 0; i < coordinateArray.length; i++) {
			positions[i] = new GeoPosition(coordinateArray[i].x, coordinateArray[i].y);
		}
		return positions;
	}

	public Geometry toJts(GeoGeometry geoGeom) {
		Geometry geom = null;

		// check type and convert
		if (geoGeom instanceof GeoPoint) {
			geom = toJtsPoint((GeoPoint)geoGeom);
		} else if (geoGeom instanceof GeoLineString) {
			geom = toJtsLineString((GeoLineString)geoGeom);
		} else if (geoGeom instanceof GeoPolygon) {
			geom = toJtsPolygon((GeoPolygon)geoGeom);
		} else {
			throw new IllegalArgumentException("Unsupported GeoGeometry type: " + geoGeom.getClass().getSimpleName());
		}

		return geom;
	}

	private Point toJtsPoint(GeoPoint geoPoint) {
		GeoPosition pos = geoPoint.getPosition();
		return geomFactory.createPoint(new Coordinate(pos.getX(), pos.getY()));
	}

	private LineString toJtsLineString(GeoLineString geoLineString) {
		Coordinate[] coords = toCoordinateArray(geoLineString.getPositions());
		return geomFactory.createLineString(coords);
	}

	private Polygon toJtsPolygon(GeoPolygon geoPolygon) {
		Coordinate[] exteriorCoords = toCoordinateArray(geoPolygon.getExterior());
		LinearRing shell = geomFactory.createLinearRing(exteriorCoords);
		LinearRing[] holes = new LinearRing[geoPolygon.getNumInteriors()];
		for (int i = 0; i < holes.length; i++) {
			Coordinate[] interiorCoords = toCoordinateArray(geoPolygon.getInterior(i));
			holes[i] = geomFactory.createLinearRing(interiorCoords);
		}
		return geomFactory.createPolygon(shell, holes);
	}

	private Coordinate[] toCoordinateArray(GeoPosition[] positionsArray) {
		GeoPosition[] positions = positionsArray;
		Coordinate[] coords = new Coordinate[positions.length];
		for (int i = 0; i < positions.length; i++) {
			coords[i] = new Coordinate(positions[i].getX(), positions[i].getY());
		}
		return coords;
	}

}


text:
var elixir = require('laravel-elixir');
require('./tasks/angular.task.js');
require('./tasks/bower.task.js');
require('./tasks/ngHtml2Js.task.js');
require('laravel-elixir-livereload');

var config = {
	assets_path: './resources/assets',
	build_path_html:'./public/views',
	build_path_css:'./public/css',
	build_path_js:'./public/js'
};
/*
|--------------------------------------------------------------------------
| Elixir Asset Management
|--------------------------------------------------------------------------
|
| Elixir provides a clean, fluent API for defining some basic Gulp tasks
| for your Laravel application. By default, we are compiling the Sass
| file for our application, as well as publishing vendor resources.
|
*/

elixir(function(mix) {
 mix
	 .bower('./bower.js')
	 .angular('./ngjs/')
	 .ngHtml2Js('./ngjs/**/*.html')
	 .less('./ngjs/**/*.less', 'public/css')
	 .copy('./ngjs/app/**/*.html', 'public')
	 .copy('./ngjs/directives/**/*.html', 'public/views')
	 .copy('./ngjs/dialogs/**/*.html', 'public/views')
	 .livereload([
		 'public/js/vendor.js',
		 'public/js/partials.js',
		 'public/js/app.js',
		 'public/css/vendor.css',
		 'public/css/app.css'
	 ], {
		 liveCSS: true
	 });

 //.phpUnit();
});


text: require 'prowler'


text:
package org.onosproject.netconf.ctl;

import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import org.onosproject.netconf.NetconfDeviceInfo;
import org.onosproject.netconf.NetconfDeviceOutputEvent;
import org.onosproject.netconf.NetconfDeviceOutputEventListener;
import org.onosproject.netconf.NetconfException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;

/**
 * Thread that gets spawned each time a session is established and handles all the input
 * and output from the session's streams to and from the NETCONF device the session is
 * established with.
 */
public class NetconfStreamThread extends Thread implements NetconfStreamHandler {

    private static final Logger log = LoggerFactory
            .getLogger(NetconfStreamThread.class);
    private static final String HELLO = "hello";
    private static final String END_PATTERN = "]]>]]>";
    private static final String RPC_REPLY = "rpc-reply";
    private static final String RPC_ERROR = "rpc-error";
    private static final String NOTIFICATION_LABEL = "<notification>";
    private static final String MESSAGE_ID = "message-id=";

    private PrintWriter outputStream;
    private final InputStream err;
    private final InputStream in;
    private NetconfDeviceInfo netconfDeviceInfo;
    private NetconfSessionDelegate sessionDelegate;
    private NetconfMessageState state;
    private  List<NetconfDeviceOutputEventListener> netconfDeviceEventListeners
            = Lists.newArrayList();

    public NetconfStreamThread(final InputStream in, final OutputStream out,
                               final InputStream err, NetconfDeviceInfo deviceInfo,
                               NetconfSessionDelegate delegate) {
        this.in = in;
        this.err = err;
        outputStream = new PrintWriter(out);
        netconfDeviceInfo = deviceInfo;
        state = NetconfMessageState.NO_MATCHING_PATTERN;
        sessionDelegate = delegate;
        log.debug("Stream thread for device {} session started", deviceInfo);
        start();
    }

    @Override
    public CompletableFuture<String> sendMessage(String request) {
        log.debug("Sending message {} to device {}", request, netconfDeviceInfo);
        outputStream.print(request);
        outputStream.flush();
        return new CompletableFuture<>();
    }

    public enum NetconfMessageState {

        NO_MATCHING_PATTERN {
            @Override
            NetconfMessageState evaluateChar(char c) {
                if (c == ']') {
                    return FIRST_BRAKET;
                } else {
                    return this;
                }
            }
        },
        FIRST_BRAKET {
            @Override
            NetconfMessageState evaluateChar(char c) {
                if (c == ']') {
                    return SECOND_BRAKET;
                } else {
                    return NO_MATCHING_PATTERN;
                }
            }
        },
        SECOND_BRAKET {
            @Override
            NetconfMessageState evaluateChar(char c) {
                if (c == '>') {
                    return FIRST_BIGGER;
                } else {
                    return NO_MATCHING_PATTERN;
                }
            }
        },
        FIRST_BIGGER {
            @Override
            NetconfMessageState evaluateChar(char c) {
                if (c == ']') {
                    return THIRD_BRAKET;
                } else {
                    return NO_MATCHING_PATTERN;
                }
            }
        },
        THIRD_BRAKET {
            @Override
            NetconfMessageState evaluateChar(char c) {
                if (c == ']') {
                    return ENDING_BIGGER;
                } else {
                    return NO_MATCHING_PATTERN;
                }
            }
        },
        ENDING_BIGGER {
            @Override
            NetconfMessageState evaluateChar(char c) {
                if (c == '>') {
                    return END_PATTERN;
                } else {
                    return NO_MATCHING_PATTERN;
                }
            }
        },
        END_PATTERN {
            @Override
            NetconfMessageState evaluateChar(char c) {
                return NO_MATCHING_PATTERN;
            }
        };

        abstract NetconfMessageState evaluateChar(char c);
    }

    public void run() {
        BufferedReader bufferReader = new BufferedReader(new InputStreamReader(in));
            try {
                boolean socketClosed = false;
                StringBuilder deviceReplyBuilder = new StringBuilder();
                while (!socketClosed) {
                    int cInt = bufferReader.read();
                    if (cInt == -1) {
                        log.debug("Netconf device {}  sent error char in session," +
                                          " will need to be reopend", netconfDeviceInfo);
                    }
                    char c = (char) cInt;
                    state = state.evaluateChar(c);
                    deviceReplyBuilder.append(c);
                    if (state == NetconfMessageState.END_PATTERN) {
                        String deviceReply = deviceReplyBuilder.toString();
                        if (deviceReply.equals(END_PATTERN)) {
                            socketClosed = true;
                            NetconfDeviceOutputEvent event = new NetconfDeviceOutputEvent(
                                    NetconfDeviceOutputEvent.Type.DEVICE_UNREGISTERED,
                                    null, null, Optional.of(-1), netconfDeviceInfo);
                            netconfDeviceEventListeners.forEach(
                                    listener -> listener.event(event));
                        } else {
                            deviceReply = deviceReply.replace(END_PATTERN, "");
                            if (deviceReply.contains(RPC_REPLY) ||
                                    deviceReply.contains(RPC_ERROR) ||
                                    deviceReply.contains(HELLO)) {
                                NetconfDeviceOutputEvent event = new NetconfDeviceOutputEvent(
                                        NetconfDeviceOutputEvent.Type.DEVICE_REPLY,
                                        null, deviceReply, getMsgId(deviceReply), netconfDeviceInfo);
                                sessionDelegate.notify(event);
                                netconfDeviceEventListeners.forEach(
                                        listener -> listener.event(event));
                            } else if (deviceReply.contains(NOTIFICATION_LABEL)) {
                                final String finalDeviceReply = deviceReply;
                                netconfDeviceEventListeners.forEach(
                                        listener -> listener.event(new NetconfDeviceOutputEvent(
                                                NetconfDeviceOutputEvent.Type.DEVICE_NOTIFICATION,
                                                null, finalDeviceReply, getMsgId(finalDeviceReply),
                                                netconfDeviceInfo)));
                            } else {
                                log.info("Error on replay from device {} ", deviceReply);
                            }
                            deviceReplyBuilder.setLength(0);
                        }
                    }
                }
            } catch (IOException e) {
                log.warn("Error in reading from the session for device {} ", netconfDeviceInfo, e);
                throw new RuntimeException(new NetconfException("Error in reading from the session for device {}" +
                                                                        netconfDeviceInfo, e));
                //TODO should we send a socket closed message to listeners ?
            }
    }

    private static Optional<Integer> getMsgId(String reply) {
        if (reply.contains(HELLO)) {
            return Optional.of(0);
        }
        if (reply.contains(RPC_ERROR) && !reply.contains(MESSAGE_ID)) {
            return Optional.empty();
        }
        String[] outer = reply.split(MESSAGE_ID);
        Preconditions.checkArgument(outer.length != 1,
                                    "Error in retrieving the message id");
        String messageID = outer[1].substring(0, 3).replace("\"", "");
        Preconditions.checkNotNull(Integer.parseInt(messageID),
                                   "Error in retrieving the message id");
        return Optional.of(Integer.parseInt(messageID));
    }

    public void addDeviceEventListener(NetconfDeviceOutputEventListener listener) {
        if (!netconfDeviceEventListeners.contains(listener)) {
            netconfDeviceEventListeners.add(listener);
        }
    }

    public void removeDeviceEventListener(NetconfDeviceOutputEventListener listener) {
        netconfDeviceEventListeners.remove(listener);
    }
}


text:
class GameManager {
public:
	static GameManager &Instance() {
		static GameManager *instance = new GameManager;
		return *instance;
	}
	void increseInfectionRate(); //occurs when an epidemic card is drawn from the player deck
	void increaseOutbreakTracker(); //occurs when there is an outbreak in a city
	void setOutbreakTracker(int i);
	void updateCubes(std::string color, int n);
	void setCubes(int red, int blue, int black, int yellow); //to use when loading i guess
	void useStation();	//used to fullfill an option of building a research station
	int getInfectionRate();
	int getOutbreakTracker();
	int getAvailableStations();
	void displayCubeCount();
	bool checkCubes();	//check if cubes are available
	bool checkOutbreak();
private:
	GameManager();
	~GameManager();
	GameManager(const GameManager &old);
	const GameManager &operator=(const GameManager &old);

	int redCubes;
	int blueCubes;
	int yellowCubes;
	int blackCubes;
	int infectionRate[7];
	int infectionRateIndex;
	int outbreakTracker;
	int researchStations;
};


text:
package net.contra.jmd.util;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.jar.JarEntry;

public final class NonClassEntries {
    public static ArrayList<JarEntry> entries = new ArrayList<JarEntry>();
    public static Map<JarEntry, InputStream> ins = new HashMap<JarEntry, InputStream>();

    private NonClassEntries() {
    }

    public static JarEntry getByName(String name) {
        for (JarEntry e : entries) {
            if (e.getName().equals(name)) {
                return e;
            }
        }
        return null;
    }

    public static byte[] readAll(InputStream inputStream) {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        while (true) {
            int len = 0;
            if (len < 0) {
                break;
            }
            try {
                len = inputStream.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (len < 0) {
                break;
            }
            bout.write(buffer, 0, len);
        }
        byte[] data = bout.toByteArray();
        return data;
    }

    public static void add(JarEntry entry, InputStream inputStream) {
        entries.add(entry);
        ins.put(entry, inputStream);
    }

}


text:
import React from 'react'
import PropTypes from 'prop-types'
import cx from 'classnames'
import { mapToCssModules } from '../../lib/'
import { BootButton } from '../../elements/BootButton'

const propTypes = {
  caret: PropTypes.bool,
  color: PropTypes.string,
  child: PropTypes.node,
  className: PropTypes.string,
  cssModule: PropTypes.object,
  disabled: PropTypes.bool,
  onClick: PropTypes.func,
  'data-toggle': PropTypes.string,
  'aria-haspopup': PropTypes.bool,
  split: PropTypes.bool,
  tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
  nav: PropTypes.bool,
}

const defaultProps = {
  'data-toggle': 'dropdown',
  'aria-haspopup': true,
  color: 'secondary',
}

const contextTypes = {
  isOpen: PropTypes.bool.isRequired,
  toggle: PropTypes.func.isRequired,
}

class DropdownToggle extends React.Component {
  constructor(props) {
    super(props)

    this.onClick = this.onClick.bind(this)
  }

  onClick(e) {
    if (this.props.disabled) {
      e.preventDefault()
      return
    }

    if (this.props.nav && !this.props.tag) {
      e.preventDefault()
    }

    if (this.props.onClick) {
      this.props.onClick(e)
    }

    this.context.toggle()
  }

  render() {
    const { className, color, cssModule, caret, split, nav, tag, ...props } = this.props
    const ariaLabel = props['aria-label'] || 'Toggle Dropdown'
    const classes = mapToCssModules(cx(
      className,
      {
        'dropdown-toggle': caret || split,
        'dropdown-toggle-split': split,
        active: this.context.isOpen,
        'nav-link': nav,
      },
    ), cssModule)
    const children = props.child || {ariaLabel}

    let Tag

    if (nav && !tag) {
      Tag = 'a'
      props.href = '#'
    } else if (!tag) {
      Tag = BootButton
      props.color = color
      props.cssModule = cssModule
    } else {
      Tag = tag
    }

    return (
      <Tag
        {...props}
        className={classes}
        onClick={this.onClick}
        aria-haspopup='true'
        aria-expanded={this.context.isOpen}
        child={children}
      />
    )
  }
}

DropdownToggle.propTypes = propTypes
DropdownToggle.defaultProps = defaultProps
DropdownToggle.contextTypes = contextTypes

export default DropdownToggle


text:
using UnityEngine;

public class PreviewSpriteAttribute : PropertyAttribute
{
    public Rect lastPosition = new Rect(0, 0, 0, 0);

    public PreviewSpriteAttribute() { }
}


text:
import React, { useState, useEffect, useRef } from "react";
import PropTypes from "prop-types";
import _ from "lodash";

function HoldHeight({ initialHeight, resetOnWindowResize, children, style }) {
  const [height, setHeight] = useState(initialHeight || 0);
  const [windowWidth, setWindowWidth] = useState(0);
  const reset = resetOnWindowResize;

  const me = useRef(null);
  const resetHeight = _.debounce(() => {
    if (windowWidth !== window.innerWidth && reset === true) {
      setHeight(initialHeight || 0);
      setWindowWidth(window.innerWidth);
    }
  }, 300);

  useEffect(() => {
    window.addEventListener("resize", () => resetHeight());
    updateHeight();

    return () => {
      window.removeEventListener("resize", () => resetHeight());
    };
  }, []);

  useEffect(() => {
    updateHeight();
  }, [children]);

  function updateHeight() {
    const refHeight = me.current.clientHeight;

    if (refHeight > height) setHeight(refHeight);
  }

  return (
    <div ref={me} style={{ ...style, minHeight: height }}>
      {children}
    </div>
  );
}

HoldHeight.propTypes = {
  resetOnWindowResize: PropTypes.bool,
  initialHeight: PropTypes.number,
};

export default HoldHeight;


text:
<!DOCTYPE html>

    <meta charset="UTF-8">
    <title>lmn.js Demo</title>

LMN:


text:
package brainslug.jpa.spring;

import brainslug.jpa.Database;
import brainslug.util.IdGenerator;
import brainslug.util.UuidGenerator;
import com.mysema.query.jpa.JPQLTemplates;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Configuration
@EnableTransactionManagement
public class SpringDatabaseConfiguration {

  @PersistenceContext
  @Qualifier("brainslug")
  EntityManager entityManager;

  @Autowired
  JPQLTemplates jpqlTemplates;

  @Bean
  Database database() {
    return new Database(entityManager, jpqlTemplates);
  }

  @Bean
  IdGenerator idGenerator() {
    return createIdGenerator();
  }

  protected IdGenerator createIdGenerator() {
    return new UuidGenerator();
  }

  @Bean
  SpringJpaPropertyStore springJpaPropertyStore() {
    return new SpringJpaPropertyStore(database(), idGenerator(), springJpaInstanceStore());
  }

  @Bean
  SpringJpaTokenStore springJpaTokenStore() {
    return new SpringJpaTokenStore(database(), idGenerator(), springJpaInstanceStore());
  }

  @Bean
  SpringJpaAsyncTriggerStore springJpaAsyncTriggerStore() {
    return new SpringJpaAsyncTriggerStore(database(), idGenerator());
  }

  @Bean
  SpringJpaInstanceStore springJpaInstanceStore() {
    return new SpringJpaInstanceStore(database(), idGenerator());
  }

}


text:
using System;
using System.Threading.Tasks;

using Orleans;

using UnitTests.GrainInterfaces;

namespace UnitTests.Grains
{
    public class MessageSerializationGrain : Grain, IMessageSerializationGrain
    {
        private IMessageSerializationGrain grainOnOtherSilo;

        public Task SendUnserializable(UnserializableType input) => Task.CompletedTask;
        public Task SendUndeserializable(UndeserializableType input) => Task.CompletedTask;
        public Task<UnserializableType> GetUnserializable() => Task.FromResult(new UnserializableType());
        public Task<UndeserializableType> GetUndeserializable() => Task.FromResult(new UndeserializableType());

        public async Task SendUndeserializableToOtherSilo()
        {
            var otherGrain = await GetGrainOnOtherSilo();

            // Message that grain in a way which should fail.
            await otherGrain.SendUndeserializable(new UndeserializableType(35));
        }

        public async Task GetUnserializableFromOtherSilo()
        {
            var otherGrain = await GetGrainOnOtherSilo();

            // Message that grain in a way which should fail.
            await otherGrain.GetUnserializable();
        }

        public async Task SendUnserializableToOtherSilo()
        {
            var otherGrain = await GetGrainOnOtherSilo();

            // Message that grain in a way which should fail.
            await otherGrain.SendUnserializable(new UnserializableType());
        }

        public async Task GetUndeserializableFromOtherSilo()
        {
            var otherGrain = await GetGrainOnOtherSilo();

            // Message that grain in a way which should fail.
            await otherGrain.GetUndeserializable();
        }

        public Task SendUndeserializableToClient(IMessageSerializationClientObject obj) => obj.SendUndeserializable(new UndeserializableType(35));
        public Task SendUnserializableToClient(IMessageSerializationClientObject obj) => obj.SendUnserializable(new UnserializableType());

        public Task GetUnserializableFromClient(IMessageSerializationClientObject obj) => obj.GetUnserializable();
        public Task GetUndeserializableFromClient(IMessageSerializationClientObject obj) => obj.GetUndeserializable();

        private async Task<IMessageSerializationGrain> GetGrainOnOtherSilo()
        {
            if (this.grainOnOtherSilo != null) return this.grainOnOtherSilo;

            // Find a grain on another silo.
            IMessageSerializationGrain otherGrain;
            var id = this.GetPrimaryKeyLong();
            var currentSiloIdentity = await this.GetSiloIdentity();
            while (true)
            {
                otherGrain = this.GrainFactory.GetGrain<IMessageSerializationGrain>(++id);
                var otherIdentity = await otherGrain.GetSiloIdentity();
                if (!string.Equals(otherIdentity, currentSiloIdentity))
                {
                    break;
                }
            }

            return this.grainOnOtherSilo = otherGrain;
        }

        public Task<string> GetSiloIdentity()
        {
            return Task.FromResult(this.RuntimeIdentity);
        }
    }
}


text:
package io.cucumber.core.plugin;

import io.cucumber.messages.types.Background;
import io.cucumber.messages.types.Feature;
import io.cucumber.messages.types.Scenario;
import io.cucumber.messages.types.Step;
import io.cucumber.plugin.EventListener;
import io.cucumber.plugin.event.Argument;
import io.cucumber.plugin.event.DataTableArgument;
import io.cucumber.plugin.event.DocStringArgument;
import io.cucumber.plugin.event.EmbedEvent;
import io.cucumber.plugin.event.EventPublisher;
import io.cucumber.plugin.event.HookTestStep;
import io.cucumber.plugin.event.HookType;
import io.cucumber.plugin.event.PickleStepTestStep;
import io.cucumber.plugin.event.Result;
import io.cucumber.plugin.event.Status;
import io.cucumber.plugin.event.StepArgument;
import io.cucumber.plugin.event.TestCase;
import io.cucumber.plugin.event.TestCaseStarted;
import io.cucumber.plugin.event.TestRunFinished;
import io.cucumber.plugin.event.TestSourceRead;
import io.cucumber.plugin.event.TestStep;
import io.cucumber.plugin.event.TestStepFinished;
import io.cucumber.plugin.event.TestStepStarted;
import io.cucumber.plugin.event.WriteEvent;

import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
import java.net.URI;
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import static io.cucumber.core.exception.ExceptionUtils.printStackTrace;
import static io.cucumber.core.plugin.TestSourcesModel.getBackgroundForTestCase;
import static java.util.Collections.singletonList;
import static java.util.Locale.ROOT;
import static java.util.stream.Collectors.toList;

public final class JsonFormatter implements EventListener {

    private static final String before = "before";
    private static final String after = "after";
    private final List<Map<String, Object>> featureMaps = new ArrayList<>();
    private final Map<String, Object> currentBeforeStepHookList = new HashMap<>();
    private final Writer writer;
    private final TestSourcesModel testSources = new TestSourcesModel();
    private URI currentFeatureFile;
    private List<Map<String, Object>> currentElementsList;
    private Map<String, Object> currentElementMap;
    private Map<String, Object> currentTestCaseMap;
    private List<Map<String, Object>> currentStepsList;
    private Map<String, Object> currentStepOrHookMap;

    @SuppressWarnings("WeakerAccess") // Used by PluginFactory
    public JsonFormatter(OutputStream out) {
        this.writer = new UTF8OutputStreamWriter(out);
    }

    @Override
    public void setEventPublisher(EventPublisher publisher) {
        publisher.registerHandlerFor(TestSourceRead.class, this::handleTestSourceRead);
        publisher.registerHandlerFor(TestCaseStarted.class, this::handleTestCaseStarted);
        publisher.registerHandlerFor(TestStepStarted.class, this::handleTestStepStarted);
        publisher.registerHandlerFor(TestStepFinished.class, this::handleTestStepFinished);
        publisher.registerHandlerFor(WriteEvent.class, this::handleWrite);
        publisher.registerHandlerFor(EmbedEvent.class, this::handleEmbed);
        publisher.registerHandlerFor(TestRunFinished.class, this::finishReport);
    }

    private void handleTestSourceRead(TestSourceRead event) {
        testSources.addTestSourceReadEvent(event.getUri(), event);
    }

    @SuppressWarnings("unchecked")
    private void handleTestCaseStarted(TestCaseStarted event) {
        if (currentFeatureFile == null || !currentFeatureFile.equals(event.getTestCase().getUri())) {
            currentFeatureFile = event.getTestCase().getUri();
            Map<String, Object> currentFeatureMap = createFeatureMap(event.getTestCase());
            featureMaps.add(currentFeatureMap);
            currentElementsList = (List<Map<String, Object>>) currentFeatureMap.get("elements");
        }
        currentTestCaseMap = createTestCase(event);
        if (testSources.hasBackground(currentFeatureFile, event.getTestCase().getLocation().getLine())) {
            currentElementMap = createBackground(event.getTestCase());
            currentElementsList.add(currentElementMap);
        } else {
            currentElementMap = currentTestCaseMap;
        }
        currentElementsList.add(currentTestCaseMap);
        currentStepsList = (List<Map<String, Object>>) currentElementMap.get("steps");
    }

    @SuppressWarnings("unchecked")
    private void handleTestStepStarted(TestStepStarted event) {
        if (event.getTestStep() instanceof PickleStepTestStep) {
            PickleStepTestStep testStep = (PickleStepTestStep) event.getTestStep();
            if (isFirstStepAfterBackground(testStep)) {
                currentElementMap = currentTestCaseMap;
                currentStepsList = (List<Map<String, Object>>) currentElementMap.get("steps");
            }
            currentStepOrHookMap = createTestStep(testStep);
            // add beforeSteps list to current step
            if (currentBeforeStepHookList.containsKey(before)) {
                currentStepOrHookMap.put(before, currentBeforeStepHookList.get(before));
                currentBeforeStepHookList.clear();
            }
            currentStepsList.add(currentStepOrHookMap);
        } else if (event.getTestStep() instanceof HookTestStep) {
            HookTestStep hookTestStep = (HookTestStep) event.getTestStep();
            currentStepOrHookMap = createHookStep(hookTestStep);
            addHookStepToTestCaseMap(currentStepOrHookMap, hookTestStep.getHookType());
        } else {
            throw new IllegalStateException();
        }
    }

    private void handleTestStepFinished(TestStepFinished event) {
        currentStepOrHookMap.put("match", createMatchMap(event.getTestStep(), event.getResult()));
        currentStepOrHookMap.put("result", createResultMap(event.getResult()));
    }

    private void handleWrite(WriteEvent event) {
        addOutputToHookMap(event.getText());
    }

    private void handleEmbed(EmbedEvent event) {
        addEmbeddingToHookMap(event.getData(), event.getMediaType(), event.getName());
    }

    private void finishReport(TestRunFinished event) {
        Throwable exception = event.getResult().getError();
        if (exception != null) {
            featureMaps.add(createDummyFeatureForFailure(event));
        }

        try {
            Jackson.OBJECT_MAPPER.writeValue(writer, featureMaps);
            writer.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private Map<String, Object> createFeatureMap(TestCase testCase) {
        Map<String, Object> featureMap = new HashMap<>();
        featureMap.put("uri", TestSourcesModel.relativize(testCase.getUri()));
        featureMap.put("elements", new ArrayList<Map<String, Object>>());
        Feature feature = testSources.getFeature(testCase.getUri());
        if (feature != null) {
            featureMap.put("keyword", feature.getKeyword());
            featureMap.put("name", feature.getName());
            featureMap.put("description", feature.getDescription() != null ? feature.getDescription() : "");
            featureMap.put("line", feature.getLocation().getLine());
            featureMap.put("id", TestSourcesModel.convertToId(feature.getName()));
            featureMap.put("tags", feature.getTags().stream().map(
                tag -> {
                    Map<String, Object> json = new LinkedHashMap<>();
                    json.put("name", tag.getName());
                    json.put("type", "Tag");
                    Map<String, Object> location = new LinkedHashMap<>();
                    location.put("line", tag.getLocation().getLine());
                    location.put("column", tag.getLocation().getColumn());
                    json.put("location", location);
                    return json;
                }).collect(toList()));

        }
        return featureMap;
    }

    private Map<String, Object> createTestCase(TestCaseStarted event) {
        Map<String, Object> testCaseMap = new HashMap<>();

        testCaseMap.put("start_timestamp", getDateTimeFromTimeStamp(event.getInstant()));

        TestCase testCase = event.getTestCase();

        testCaseMap.put("name", testCase.getName());
        testCaseMap.put("line", testCase.getLine());
        testCaseMap.put("type", "scenario");
        TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testCase.getLine());
        if (astNode != null) {
            testCaseMap.put("id", TestSourcesModel.calculateId(astNode));
            Scenario scenarioDefinition = TestSourcesModel.getScenarioDefinition(astNode);
            testCaseMap.put("keyword", scenarioDefinition.getKeyword());
            testCaseMap.put("description",
                scenarioDefinition.getDescription() != null ? scenarioDefinition.getDescription() : "");
        }
        testCaseMap.put("steps", new ArrayList<Map<String, Object>>());
        if (!testCase.getTags().isEmpty()) {
            List<Map<String, Object>> tagList = new ArrayList<>();
            for (String tag : testCase.getTags()) {
                Map<String, Object> tagMap = new HashMap<>();
                tagMap.put("name", tag);
                tagList.add(tagMap);
            }
            testCaseMap.put("tags", tagList);
        }
        return testCaseMap;
    }

    private Map<String, Object> createBackground(TestCase testCase) {
        TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testCase.getLocation().getLine());
        if (astNode != null) {
            Background background = getBackgroundForTestCase(astNode).get();
            Map<String, Object> testCaseMap = new HashMap<>();
            testCaseMap.put("name", background.getName());
            testCaseMap.put("line", background.getLocation().getLine());
            testCaseMap.put("type", "background");
            testCaseMap.put("keyword", background.getKeyword());
            testCaseMap.put("description", background.getDescription() != null ? background.getDescription() : "");
            testCaseMap.put("steps", new ArrayList<Map<String, Object>>());
            return testCaseMap;
        }
        return null;
    }

    private boolean isFirstStepAfterBackground(PickleStepTestStep testStep) {
        TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testStep.getStepLine());
        if (astNode == null) {
            return false;
        }
        return currentElementMap != currentTestCaseMap && !TestSourcesModel.isBackgroundStep(astNode);
    }

    private Map<String, Object> createTestStep(PickleStepTestStep testStep) {
        Map<String, Object> stepMap = new HashMap<>();
        stepMap.put("name", testStep.getStepText());
        stepMap.put("line", testStep.getStepLine());
        TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testStep.getStepLine());
        StepArgument argument = testStep.getStepArgument();
        if (argument != null) {
            if (argument instanceof DocStringArgument) {
                DocStringArgument docStringArgument = (DocStringArgument) argument;
                stepMap.put("doc_string", createDocStringMap(docStringArgument));
            } else if (argument instanceof DataTableArgument) {
                DataTableArgument dataTableArgument = (DataTableArgument) argument;
                stepMap.put("rows", createDataTableList(dataTableArgument));
            }
        }
        if (astNode != null) {
            Step step = (Step) astNode.node;
            stepMap.put("keyword", step.getKeyword());
        }

        return stepMap;
    }

    private Map<String, Object> createHookStep(HookTestStep hookTestStep) {
        return new HashMap<>();
    }

    private void addHookStepToTestCaseMap(Map<String, Object> currentStepOrHookMap, HookType hookType) {
        String hookName;
        if (hookType == HookType.AFTER || hookType == HookType.AFTER_STEP)
            hookName = after;
        else
            hookName = before;

        Map<String, Object> mapToAddTo;
        switch (hookType) {
            case BEFORE:
                mapToAddTo = currentTestCaseMap;
                break;
            case AFTER:
                mapToAddTo = currentTestCaseMap;
                break;
            case BEFORE_STEP:
                mapToAddTo = currentBeforeStepHookList;
                break;
            case AFTER_STEP:
                mapToAddTo = currentStepsList.get(currentStepsList.size() - 1);
                break;
            default:
                mapToAddTo = currentTestCaseMap;
        }

        if (!mapToAddTo.containsKey(hookName)) {
            mapToAddTo.put(hookName, new ArrayList<Map<String, Object>>());
        }
        ((List<Map<String, Object>>) mapToAddTo.get(hookName)).add(currentStepOrHookMap);
    }

    private Map<String, Object> createMatchMap(TestStep step, Result result) {
        Map<String, Object> matchMap = new HashMap<>();
        if (step instanceof PickleStepTestStep) {
            PickleStepTestStep testStep = (PickleStepTestStep) step;
            if (!testStep.getDefinitionArgument().isEmpty()) {
                List<Map<String, Object>> argumentList = new ArrayList<>();
                for (Argument argument : testStep.getDefinitionArgument()) {
                    Map<String, Object> argumentMap = new HashMap<>();
                    if (argument.getValue() != null) {
                        argumentMap.put("val", argument.getValue());
                        argumentMap.put("offset", argument.getStart());
                    }
                    argumentList.add(argumentMap);
                }
                matchMap.put("arguments", argumentList);
            }
        }
        if (!result.getStatus().is(Status.UNDEFINED)) {
            matchMap.put("location", step.getCodeLocation());
        }
        return matchMap;
    }

    private Map<String, Object> createResultMap(Result result) {
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("status", result.getStatus().name().toLowerCase(ROOT));
        if (result.getError() != null) {
            resultMap.put("error_message", printStackTrace(result.getError()));
        }
        if (!result.getDuration().isZero()) {
            resultMap.put("duration", result.getDuration().toNanos());
        }
        return resultMap;
    }

    private void addOutputToHookMap(String text) {
        if (!currentStepOrHookMap.containsKey("output")) {
            currentStepOrHookMap.put("output", new ArrayList<String>());
        }
        ((List<String>) currentStepOrHookMap.get("output")).add(text);
    }

    private void addEmbeddingToHookMap(byte[] data, String mediaType, String name) {
        if (!currentStepOrHookMap.containsKey("embeddings")) {
            currentStepOrHookMap.put("embeddings", new ArrayList<Map<String, Object>>());
        }
        Map<String, Object> embedMap = createEmbeddingMap(data, mediaType, name);
        ((List<Map<String, Object>>) currentStepOrHookMap.get("embeddings")).add(embedMap);
    }

    private Map<String, Object> createDummyFeatureForFailure(TestRunFinished event) {
        Throwable exception = event.getResult().getError();

        Map<String, Object> feature = new LinkedHashMap<>();
        feature.put("line", 1);
        {
            Map<String, Object> scenario = new LinkedHashMap<>();
            feature.put("elements", singletonList(scenario));

            scenario.put("start_timestamp", getDateTimeFromTimeStamp(event.getInstant()));
            scenario.put("line", 2);
            scenario.put("name", "Failure while executing Cucumber");
            scenario.put("description", "");
            scenario.put("id", "failure;failure-while-executing-cucumber");
            scenario.put("type", "scenario");
            scenario.put("keyword", "Scenario");

            Map<String, Object> when = new LinkedHashMap<>();
            Map<String, Object> then = new LinkedHashMap<>();
            scenario.put("steps", Arrays.asList(when, then));
            {

                {
                    Map<String, Object> whenResult = new LinkedHashMap<>();
                    when.put("result", whenResult);
                    whenResult.put("duration", 0);
                    whenResult.put("status", "passed");
                }
                when.put("line", 3);
                when.put("name", "Cucumber failed while executing");
                Map<String, Object> whenMatch = new LinkedHashMap<>();
                when.put("match", whenMatch);
                whenMatch.put("arguments", new ArrayList<>());
                whenMatch.put("location", "io.cucumber.core.Failure.failure_while_executing_cucumber()");
                when.put("keyword", "When ");

                {
                    Map<String, Object> thenResult = new LinkedHashMap<>();
                    then.put("result", thenResult);
                    thenResult.put("duration", 0);
                    thenResult.put("error_message", printStackTrace(exception));
                    thenResult.put("status", "failed");
                }
                then.put("line", 4);
                then.put("name", "Cucumber will report this error:");
                Map<String, Object> thenMatch = new LinkedHashMap<>();
                then.put("match", thenMatch);
                thenMatch.put("arguments", new ArrayList<>());
                thenMatch.put("location", "io.cucumber.core.Failure.cucumber_reports_this_error()");
                then.put("keyword", "Then ");
            }

            feature.put("name", "Test run failed");
            feature.put("description", "There were errors during the execution");
            feature.put("id", "failure");
            feature.put("keyword", "Feature");
            feature.put("uri", "classpath:io/cucumber/core/failure.feature");
            feature.put("tags", new ArrayList<>());
        }

        return feature;
    }

    private String getDateTimeFromTimeStamp(Instant instant) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX")
                .withZone(ZoneOffset.UTC);
        return formatter.format(instant);
    }

    private Map<String, Object> createDocStringMap(DocStringArgument docString) {
        Map<String, Object> docStringMap = new HashMap<>();
        docStringMap.put("value", docString.getContent());
        docStringMap.put("line", docString.getLine());
        docStringMap.put("content_type", docString.getMediaType());
        return docStringMap;
    }

    private List<Map<String, List<String>>> createDataTableList(DataTableArgument argument) {
        List<Map<String, List<String>>> rowList = new ArrayList<>();
        for (List<String> row : argument.cells()) {
            Map<String, List<String>> rowMap = new HashMap<>();
            rowMap.put("cells", new ArrayList<>(row));
            rowList.add(rowMap);
        }
        return rowList;
    }

    private Map<String, Object> createEmbeddingMap(byte[] data, String mediaType, String name) {
        Map<String, Object> embedMap = new HashMap<>();
        embedMap.put("mime_type", mediaType); // Should be media-type but not
                                              // worth migrating for
        embedMap.put("data", Base64.getEncoder().encodeToString(data));
        if (name != null) {
            embedMap.put("name", name);
        }
        return embedMap;
    }

}


text:
<?php

/**
 * Object for doing specific actions to a vBulletin import.
 */
class vBulletinImportModel extends Gdn_Model {

    /** @var ImportModel */
    var $ImportModel = null;

    /**
     * Custom finalization.
     *
     * @throws Exception
     */
    public function afterImport() {
        // Set up the routes to redirect from their older counterparts.
        $Router = Gdn::router();

        // Categories
        $Router->SetRoute('forumdisplay\.php\?f=(\d+)', 'categories/$1', 'Permanent');
        $Router->SetRoute('archive\.php/f-(\d+)\.html', 'categories/$1', 'Permanent');

        // Discussions & Comments
        $Router->SetRoute('showthread\.php\?t=(\d+)', 'discussion/$1', 'Permanent');
        //$Router->SetRoute('showthread\.php\?p=(\d+)', 'discussion/comment/$1#Comment_$1', 'Permanent');
        //$Router->SetRoute('showpost\.php\?p=(\d+)', 'discussion/comment/$1#Comment_$1', 'Permanent');
        $Router->SetRoute('archive\.php/t-(\d+)\.html', 'discussion/$1', 'Permanent');

        // Profiles
        $Router->SetRoute('member\.php\?u=(\d+)', 'profile/$1/x', 'Permanent');
        $Router->SetRoute('usercp\.php', 'profile', 'Permanent');
        $Router->SetRoute('profile\.php', 'profile', 'Permanent');

        // Other
        $Router->SetRoute('attachment\.php\?attachmentid=(\d+)', 'discussion/download/$1', 'Permanent');
        $Router->SetRoute('search\.php', 'discussions', 'Permanent');
        $Router->SetRoute('private\.php', 'messages/all', 'Permanent');
        $Router->SetRoute('subscription\.php', 'discussions/bookmarked', 'Permanent');

        // Make different sizes of avatars
        $this->ProcessAvatars();

        // Prep config for ProfileExtender plugin based on imported fields
        $this->ProfileExtenderPrep();

        // Set guests to System user to prevent security issues
        $SystemUserID = Gdn::userModel()->GetSystemUserID();
        $this->SQL->update('Discussion')
            ->set('InsertUserID', $SystemUserID)
            ->where('InsertUserID', 0)
            ->put();
        $this->SQL->update('Comment')
            ->set('InsertUserID', $SystemUserID)
            ->where('InsertUserID', 0)
            ->put();
    }

    /**
     * Create different sizes of user photos.
     */
    public function processAvatars() {
        $UploadImage = new Gdn_UploadImage();
        $UserData = $this->SQL->select('u.Photo')->from('User u')->where('u.Photo is not null')->get();

        // Make sure the avatars folder exists.
        if (!file_exists(PATH_UPLOADS.'/userpics')) {
            mkdir(PATH_UPLOADS.'/userpics');
        }

        // Get sizes
        $ProfileHeight = c('Garden.Profile.MaxHeight', 1000);
        $ProfileWidth = c('Garden.Profile.MaxWidth', 250);
        $ThumbSize = c('Garden.Thumbnail.Size', 40);

        // Temporarily set maximum quality
        saveToConfig('Garden.UploadImage.Quality', 100, false);

        // Create profile and thumbnail sizes
        foreach ($UserData->result() as $User) {
            try {
                $Image = PATH_ROOT.DS.'uploads'.DS.GetValue('Photo', $User);
                $ImageBaseName = pathinfo($Image, PATHINFO_BASENAME);

                // Save profile size
                $UploadImage->SaveImageAs(
                    $Image,
                    PATH_UPLOADS.'/userpics/p'.$ImageBaseName,
                    $ProfileHeight,
                    $ProfileWidth
                );

                // Save thumbnail size
                $UploadImage->SaveImageAs(
                    $Image,
                    PATH_UPLOADS.'/userpics/n'.$ImageBaseName,
                    $ThumbSize,
                    $ThumbSize,
                    true
                );
            } catch (Exception $ex) {
            }
        }
    }

    /**
     * Get profile fields imported and add to ProfileFields list.
     */
    public function profileExtenderPrep() {
        $ProfileKeyData = $this->SQL->select('m.Name')->Distinct()->from('UserMeta m')->like('m.Name', 'Profile_%')->get();
        $ExistingKeys = array_filter((array)explode(',', c('Plugins.ProfileExtender.ProfileFields', '')));
        foreach ($ProfileKeyData->result() as $Key) {
            $Name = str_replace('Profile.', '', $Key->Name);
            if (!in_array($Name, $ExistingKeys)) {
                $ExistingKeys[] = $Name;
            }
        }
        if (count($ExistingKeys)) {
            saveToConfig('Plugins.ProfileExtender.ProfileFields', implode(',', $ExistingKeys));
        }
    }
}


text:
(function() {
  var Gridlike = function(options) {
    this.grid = null;
    this.isVisible = false;

    this.id = null;
    this.columns = null;
    this.classNames = {
      grid: 'gridlike',
      column: 'gridlike__column'
    };

    this.init = function(options) {
      this.initOptions(options);
      this.initEventListener();

      this.createGrid();
      document.body.appendChild(this.grid);

      return this.grid;
    }

    this.initOptions = function(options) {
      this.columns = options.columns || this.columns;

      var classNames = options.classNames || {};
      classNames.grid = options.classNames.grid || this.classNames.grid;
      classNames.column = options.classNames.column || this.classNames.column;
      this.classNames = classNames;
    }

    this.initEventListener = function() {
      document.addEventListener('keydown', function(event) {
        if (this.isElementAcceptingKeyInput(event.target)) {
          return;
        }

        if (event.keyCode != 71) {  // 'g'
          return;
        }

        this.isVisible = !this.isVisible;
        this.grid.style.display = this.isVisible ? 'block' : 'none';
      }.bind(this));
    }

    this.isElementAcceptingKeyInput = function(element) {
      var nodeNames = [
        'INPUT',
        'TEXTAREA',
        'SELECT', // <select> and option doesn't seem to trigger a keydown
        'OPTION'  // event, but we test them just in case.
      ];

      for (var i = 0; i < nodeNames.length; i++) {
        if (element.nodeName == nodeNames[i]) {
          return true;
        }
      }

      return false;
    }

    this.createGrid = function() {
      this.grid = this.createElement(this.classNames.grid);
      this.grid.style.display = 'none',
      this.grid.style.pointerEvents = 'none';

      for (var i = 0; i < this.columns; i++) {
        this.grid.appendChild(this.createElement(this.classNames.column));
      }
    }

    this.createElement = function(className) {
      var element = document.createElement('div');
      element.className = className;
      return element;
    }

    return this.init(options);
  };

  if (typeof module !== 'undefined' && typeof module.exports === 'object') {
    module.exports = Gridlike;
  }
  else {
    if (typeof window !== 'undefined') {
      window.Gridlike = Gridlike
    };
  }

  return Gridlike;
})();


text:
package logs

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/url"
	"path/filepath"
	"strings"
	"time"

	"github.com/dokku/dokku/plugins/common"
	"github.com/joncalhoun/qson"
)

type vectorConfig struct {
	Sources map[string]vectorSource `json:"sources"`
	Sinks   map[string]vectorSink   `json:"sinks"`
}

type vectorSource struct {
	Type          string   `json:"type"`
	IncludeLabels []string `json:"include_labels,omitempty"`
}

type vectorSink map[string]interface{}

const vectorContainerName = "vector"

func killVectorContainer() error {
	if !common.ContainerExists(vectorContainerName) {
		return nil
	}

	if err := stopVectorContainer(); err != nil {
		return err
	}

	time.Sleep(10 * time.Second)
	if err := removeVectorContainer(); err != nil {
		return err
	}

	return nil
}

func removeVectorContainer() error {
	if !common.ContainerExists(vectorContainerName) {
		return nil
	}

	cmd := common.NewShellCmd(strings.Join([]string{
		common.DockerBin(), "container", "rm", "-f", vectorContainerName}, " "))

	return common.SuppressOutput(func() error {
		if cmd.Execute() {
			return nil
		}

		if common.ContainerExists(vectorContainerName) {
			return errors.New("Unable to remove vector container")
		}

		return nil
	})
}

func startVectorContainer(vectorImage string) error {
	cmd := common.NewShellCmd(strings.Join([]string{
		common.DockerBin(),
		"container",
		"run", "--detach", "--name", vectorContainerName, common.MustGetEnv("DOKKU_GLOBAL_RUN_ARGS"),
		"--volume", "/var/lib/dokku/data/logs/vector.json:/etc/vector/vector.json",
		"--volume", "/var/run/docker.sock:/var/run/docker.sock",
		"--volume", common.MustGetEnv("DOKKU_LOGS_HOST_DIR") + ":/var/logs/dokku/apps",
		"--volume", common.MustGetEnv("DOKKU_LOGS_HOST_DIR") + "/apps:/var/log/dokku/apps",
		vectorImage,
		"--config", "/etc/vector/vector.json", "--watch-config", "1"}, " "))
	cmd.ShowOutput = false

	if !cmd.Execute() {
		return errors.New("Unable to start vector container")
	}

	return nil
}

func stopVectorContainer() error {
	if !common.ContainerExists(vectorContainerName) {
		return nil
	}

	if !common.ContainerIsRunning(vectorContainerName) {
		return nil
	}

	cmd := common.NewShellCmd(strings.Join([]string{
		common.DockerBin(), "container", "stop", vectorContainerName}, " "))

	return common.SuppressOutput(func() error {
		if cmd.Execute() {
			return nil
		}

		if common.ContainerIsRunning(vectorContainerName) {
			return errors.New("Unable to stop vector container")
		}

		return nil
	})
}

func sinkValueToConfig(appName string, sinkValue string) (vectorSink, error) {
	var data vectorSink
	if strings.Contains(sinkValue, "://") {
		parts := strings.SplitN(sinkValue, "://", 2)
		parts[0] = strings.ReplaceAll(parts[0], "_", "-")
		sinkValue = strings.Join(parts, "://")
	}
	u, err := url.Parse(sinkValue)
	if err != nil {
		return data, err
	}

	if u.Query().Get("sinks") != "" {
		return data, errors.New("Invalid option sinks")
	}

	u.Scheme = strings.ReplaceAll(u.Scheme, "-", "_")

	t := fmt.Sprintf("type=%s", u.Scheme)
	i := fmt.Sprintf("inputs[]=docker-source:%s", appName)
	if appName == "--global" {
		i = "inputs[]=docker-global-source"
	}
	if appName == "--null" {
		i = "inputs[]=docker-null-source"
	}

	initialQuery := fmt.Sprintf("%s&%s", t, i)
	query := u.RawQuery
	if query == "" {
		query = initialQuery
	} else if strings.HasPrefix(query, "&") {
		query = fmt.Sprintf("%s%s", initialQuery, query)
	} else {
		query = fmt.Sprintf("%s&%s", initialQuery, query)
	}

	b, err := qson.ToJSON(query)
	if err != nil {
		return data, err
	}

	if err := json.Unmarshal(b, &data); err != nil {
		return data, err
	}

	return data, nil
}

func writeVectorConfig() error {
	apps, _ := common.DokkuApps()
	data := vectorConfig{
		Sources: map[string]vectorSource{},
		Sinks:   map[string]vectorSink{},
	}
	for _, appName := range apps {
		value := common.PropertyGet("logs", appName, "vector-sink")
		if value == "" {
			continue
		}

		sink, err := sinkValueToConfig(appName, value)
		if err != nil {
			return err
		}

		data.Sources[fmt.Sprintf("docker-source:%s", appName)] = vectorSource{
			Type:          "docker_logs",
			IncludeLabels: []string{fmt.Sprintf("com.dokku.app-name=%s", appName)},
		}

		data.Sinks[fmt.Sprintf("docker-sink:%s", appName)] = sink
	}

	value := common.PropertyGet("logs", "--global", "vector-sink")
	if value != "" {
		sink, err := sinkValueToConfig("--global", value)
		if err != nil {
			return err
		}

		data.Sources["docker-global-source"] = vectorSource{
			Type:          "docker_logs",
			IncludeLabels: []string{"com.dokku.app-name"},
		}

		data.Sinks["docker-global-sink"] = sink
	}

	if len(data.Sources) == 0 {
		// pull from no containers
		data.Sources["docker-null-source"] = vectorSource{
			Type:          "docker_logs",
			IncludeLabels: []string{"com.dokku.vector-null"},
		}
	}

	if len(data.Sinks) == 0 {
		// write logs to a blackhole
		sink, err := sinkValueToConfig("--null", "blackhole://?print_amount=1")
		if err != nil {
			return err
		}

		data.Sinks["docker-null-sink"] = sink
	}

	b, err := json.MarshalIndent(data, "", "  ")
	if err != nil {
		return err
	}

	vectorConfig := filepath.Join(common.MustGetEnv("DOKKU_LIB_ROOT"), "data", "logs", "vector.json")
	if err := common.WriteSliceToFile(vectorConfig, []string{string(b)}); err != nil {
		return err
	}

	return nil
}


text:
<?xml version="1.0" encoding="utf-8"?>
<table name="KnoxUpgrade">
    <package name="com.samsung.android.mdm" />
</table>


text:
<?php

$config = [
    'components' => [
        'request' => [
            // !!! insert a secret key in the following (if it is empty) - this is required by cookie validation
            'cookieValidationKey' => env('BACKEND_COOKIE_VALIDATION_KEY')
        ],
        'urlManager' => [
            'enablePrettyUrl' => env('backend_enable_pretty_url', false),
            'showScriptName' => false,
        ],
    ],
];

return $config;


text:
"""Utilities module containing SQL queries to be executed during the data extraction.

The following global variables are published by this module:
	* QUERY_TEMP_DATA_TEMPLATE - Query template to shuffle the source data and save it
	in a temporary table.
	* QUERY_TRAINING_DATA_TEMPLATE - Query template to extract from the shuffled temporary
	table the training data.
	* QUERY_VALIDATION_DATA_TEMPLATE - Query template to extract from the shuffled
	temporary table the validation data.
"""

# Query template to shuffle the source data and save it in a temporary table.
QUERY_TEMP_DATA_TEMPLATE = """
	CREATE OR REPLACE TABLE
	  `{temp_table}`
	AS
	SELECT
		CAST(RAND() * {total_lines} AS INT64) AS random,
		*
	FROM (
		SELECT
			{feature_columns}, {target_columns_shuffle}
		FROM
			`{source_table}`
	)
"""

# Query template to extract from the shuffled temporary table the training data.
QUERY_TRAINING_DATA_TEMPLATE = """
	CREATE OR REPLACE TABLE
	  `{destination_table}`
	AS
	SELECT
		{feature_columns}, {target_columns_export}
	FROM
  		`{temp_table}`
  WHERE
  		random <= {split_index}
"""

# Query template to extract from the shuffled temporary table the validation data.
QUERY_VALIDATION_DATA_TEMPLATE = """
	CREATE OR REPLACE TABLE
	  `{destination_table}`
	AS
	SELECT
	  {feature_columns}, {target_columns_export}
	FROM
	  `{temp_table}`
	WHERE
  		random > {split_index}
"""


text:
var assert = require('chai').assert;

describe('User', function() {

  describe('attributes', function() {
    it('is invalid without an username', function(done) {
      User.create({password: 'test', name: null}).exec(function(err, user) {
        assert.equal(user, undefined);
        done();
      })
    });
    it('is invalid without a password', function(done) {
      User.create({name: 'user', password: null}).exec(function(err, user) {
        assert.equal(user, undefined);
        done();
      })
    });
  });

  describe('#toJSON', function() {
    it('does not includes user\'s password', function(done) {
      User.create({username: 'testusername', password: 'test'}).exec(function(err, user) {
        User.destroy({username: 'testusername'}).exec(function(err) {
          assert.equal(user.toJSON()['password'], undefined);
          done();
        })
      })
    })
  })

});
/**
 * Created by piotrowy on 16.05.2016.
 */


text:
using System;
using StackingEntities.Model.Enums;

namespace StackingEntities.Model.Entities.Other
{
	[Serializable]
	public class LeashKnot : EntityBase
	{
		public LeashKnot ()
		{
			Type = EntityType.LeashKnot;
		}

		public override string DisplayImage => "/StackingEntities.Resources;component/Images/Other/Lead.png";
	}
}


text:
'use strict';

var chai = require('chai'),
    angular = require('camunda-bpm-sdk-js/vendor/angular'),
    ngRoute = require('angular-route'),
    authModule = require('../index');

var expect = chai.expect;

describe('camunda-commons-ui/auth/directives', function() {

  beforeEach(window.module(authModule.name));

  beforeEach(window.module(function($provide) {
    $provide.value('shouldDisplayAuthenticationError', function() {
      return true;
    });
  }));

  describe('<cam-if-logged-in>', function() {

    var doc, element;

    beforeEach(inject(function($httpBackend, $rootScope, $compile) {
      doc = $('

logged-in

').appendTo('body');
      element = doc.find('> div');
    }));

    afterEach(function() {
      doc.remove();
    });

    it('should show on logged in', inject(function($rootScope, $compile) {
      // given
      $rootScope.authentication = { name: 'klaus' };

      // when
      element = $compile(element)($rootScope);
      $rootScope.$digest();

      // then
      expect(doc.text()).to.equal('logged-in');
    }));

    it('should hide on logged out', inject(function($rootScope, $compile) {
      // given
      $rootScope.authentication = null;

      // when
      element = $compile(element)($rootScope);
      $rootScope.$digest();

      // then
      expect(doc.text()).to.equal('');
    }));

    it('should update on <authentication.changed>', inject(function($rootScope, $compile) {
      // given
      $rootScope.authentication = null;

      element = $compile(element)($rootScope);
      $rootScope.$digest();

      // when
      $rootScope.$broadcast('authentication.changed', { name: 'klaus' });
      $rootScope.$digest();

      // then
      expect(doc.text()).to.equal('logged-in');
    }));

  });

  describe('<cam-if-logged-out>', function() {

    var doc, element;

    beforeEach(inject(function($httpBackend, $rootScope, $compile) {
      doc = $('

logged-out

').appendTo('body');
      element = doc.find('> div');
    }));

    afterEach(function() {
      doc.remove();
    });

    it('should hide on logged in', inject(function($rootScope, $compile) {
      // given
      $rootScope.authentication = { name: 'klaus' };

      // when
      element = $compile(element)($rootScope);
      $rootScope.$digest();

      // then
      expect(doc.text()).to.equal('');
    }));

    it('should show on logged out', inject(function($rootScope, $compile) {
      // given
      $rootScope.authentication = null;

      // when
      element = $compile(element)($rootScope);
      $rootScope.$digest();

      // then
      expect(doc.text()).to.equal('logged-out');
    }));

    it('should update on <authentication.changed>', inject(function($rootScope, $compile) {
      // given
      $rootScope.authentication = null;

      element = $compile(element)($rootScope);
      $rootScope.$digest();

      // when
      $rootScope.$broadcast('authentication.changed', { name: 'klaus' });
      $rootScope.$digest();

      // then
      expect(doc.text()).to.equal('');
    }));

  });

});