internal ConfigurationIssuer(ConfigurationIssuer reference)
        {
            //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();
            this._002Ector();
            ContextClientBridge.RunClient(reference, "other");
            int num = 0;

            foreach (ParserFilterResolver item in (IEnumerable <ParserFilterResolver>)reference)
            {
                ManageClass(num, item, ignoretag: false);
                num++;
            }
        }
        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);
        }
        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());
        }