private void ResolveClass(RecordClassDispatcher task, IDynamicMetaObjectProvider connection, ProducerProperty role, ProductInstanceExpression last2, InitializerTest result3, ProductInstanceExpression reg4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            ManageBroadcaster(task, role, connection);
            wrapperProperty.Add(connection);
            SortBroadcaster(task, connection, role, last2, result3, reg4);
            int lengthpred = task._0002();

            for (int i = 0; i < role._0001().Count; i++)
            {
                ProductInstanceExpression productInstanceExpression = role._0001()[i];
                if (productInstanceExpression._0004())
                {
                    try
                    {
                        if (CollectBroadcaster(task, connection, role, last2, productInstanceExpression, out ProcTest _0007, out object _0008))
                        {
                            productInstanceExpression.DefineClient(task);
                            InvokeBroadcaster(task, _0008, _0007, productInstanceExpression, role, last2);
                        }
                    }
                    catch (Exception ident)
                    {
                        if (!CheckBroadcaster(connection, role, productInstanceExpression._0001(), null, task._0001(), ident))
                        {
                            throw;
                        }
                        EnableClass(task, lengthpred);
                    }
                }
            }
            foreach (string item in connection.ResolveIssuer())
            {
                if (role.CancelClient(connection, item, out object _0004))
                {
                    try
                    {
                        ProcTest procTest = DeleteBroadcaster(_0004);
                        if (FillClass(_0004) && CustomizeBroadcaster(task, _0004, null, procTest, role, last2))
                        {
                            string task2 = (role._0001() != null) ? role._0001()(item) : item;
                            task._0002(task2);
                            InvokeBroadcaster(task, _0004, procTest, null, role, last2);
                        }
                    }
                    catch (Exception ident2)
                    {
                        if (!CheckBroadcaster(connection, role, item, null, task._0001(), ident2))
                        {
                            throw;
                        }
                        EnableClass(task, lengthpred);
                    }
                }
            }
            task._0011();
            wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
            InitBroadcaster(task, role, connection);
        }
        private void DefineBroadcaster(RecordClassDispatcher task, object visitor, PrototypeFilterResolver proc, ProductInstanceExpression cust2, InitializerTest first3, ProductInstanceExpression v4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            ManageBroadcaster(task, proc, visitor);
            wrapperProperty.Add(visitor);
            SortBroadcaster(task, visitor, proc, cust2, first3, v4);
            int lengthpred = task._0002();

            for (int i = 0; i < proc._0001().Count; i++)
            {
                ProductInstanceExpression productInstanceExpression = proc._0001()[i];
                try
                {
                    if (CollectBroadcaster(task, visitor, proc, cust2, productInstanceExpression, out ProcTest _0007, out object _0008))
                    {
                        productInstanceExpression.DefineClient(task);
                        InvokeBroadcaster(task, _0008, _0007, productInstanceExpression, proc, cust2);
                    }
                }
                catch (Exception ident)
                {
                    if (!CheckBroadcaster(visitor, proc, productInstanceExpression._0001(), null, task._0001(), ident))
                    {
                        throw;
                    }
                    EnableClass(task, lengthpred);
                }
            }
            IEnumerable <KeyValuePair <object, object> > enumerable = proc._0001()?.Invoke(visitor);

            if (enumerable != null)
            {
                foreach (KeyValuePair <object, object> item in enumerable)
                {
                    ProcTest temp     = TestBroadcaster(item.Key);
                    ProcTest procTest = DeleteBroadcaster(item.Value);
                    string   text     = AddClass(task, item.Key, temp, out bool _);
                    text = ((proc._0001() != null) ? proc._0001()(text) : text);
                    if (CountBroadcaster(item.Value, null, procTest, proc, cust2))
                    {
                        task._0002(text);
                        QueryBroadcaster(task, item.Value);
                    }
                    else if (CustomizeBroadcaster(task, item.Value, null, procTest, proc, cust2))
                    {
                        task._0002(text);
                        InvokeBroadcaster(task, item.Value, procTest, null, proc, cust2);
                    }
                }
            }
            task._0011();
            wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
            InitBroadcaster(task, proc, visitor);
        }
        private bool CollectBroadcaster(RecordClassDispatcher init, object pol, InitializerTest helper, [global::_0008._0012(2)] ProductInstanceExpression _0005, ProductInstanceExpression asset3, [global::_0008._0012(2)][ConsumerBroadcasterDispatcher(true)] out ProcTest _0007, [ConsumerBroadcasterDispatcher(true)][global::_0008._0012(2)] out object _0008)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (!asset3._0001() && asset3._0002() && MapClass(init, asset3, pol) && InsertClass(init, asset3, pol))
            {
                if (asset3._0001() == null)
                {
                    asset3._0001(baseProperty.listenerError._0001(asset3._0002()));
                }
                _0008 = asset3._0001()._0001(pol);
                _0007 = (asset3._0001().propertyProperty ? asset3._0001() : DeleteBroadcaster(_0008));
                if (AssetBroadcaster(_0008, helper as PrototypeFilterResolver, asset3))
                {
                    if (CountBroadcaster(_0008, asset3, _0007, helper, _0005))
                    {
                        asset3.DefineClient(init);
                        QueryBroadcaster(init, _0008);
                        return(false);
                    }
                    if (!CustomizeBroadcaster(init, _0008, asset3, _0007, helper, _0005))
                    {
                        return(false);
                    }
                    if (_0008 == null)
                    {
                        PrototypeFilterResolver prototypeFilterResolver = helper as PrototypeFilterResolver;
                        switch (asset3.contextProperty ?? (prototypeFilterResolver?._0001()).GetValueOrDefault())
                        {
                        case (SpecificationTestItem)2:
                            throw StrategyError.ValidateComposer(null, init._0001(), "Cannot write a null value for property '{0}'. Property requires a value.".ListReader(CultureInfo.InvariantCulture, asset3._0001()), null);

                        case (SpecificationTestItem)3:
                            throw StrategyError.ValidateComposer(null, init._0001(), "Cannot write a null value for property '{0}'. Property requires a non-null value.".ListReader(CultureInfo.InvariantCulture, asset3._0001()), null);
                        }
                    }
                    return(true);
                }
            }
            _0007 = null;
            _0008 = null;
            return(false);
        }