private bool CustomizeBroadcaster(RecordClassDispatcher res, object pol, ProductInstanceExpression filter, ProcTest second2, InitializerTest cfg3, ProductInstanceExpression visitor4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (pol == null)
            {
                return(true);
            }
            if (second2._ErrorProperty == (ParameterFilterResolver)3 || second2._ErrorProperty == (ParameterFilterResolver)4)
            {
                return(true);
            }
            FacadeComposer?facadeComposer = null;

            if (filter != null)
            {
                facadeComposer = filter._0001();
            }
            if (!facadeComposer.HasValue && visitor4 != null)
            {
                facadeComposer = visitor4._0002();
            }
            if (!facadeComposer.HasValue && cfg3 != null)
            {
                facadeComposer = cfg3._0001();
            }
            if ((baseProperty.m_SpecificationError != null) ? wrapperProperty.CollectTest(pol, baseProperty.m_SpecificationError) : wrapperProperty.Contains(pol))
            {
                string str = "Self referencing loop detected";
                if (filter != null)
                {
                    str += " for property '{0}'".ListReader(CultureInfo.InvariantCulture, filter._0001());
                }
                str += " with type '{0}'.".ListReader(CultureInfo.InvariantCulture, pol.GetType());
                switch (facadeComposer.GetValueOrDefault(baseProperty.helperError))
                {
                case (FacadeComposer)0:
                    throw StrategyError.ValidateComposer(null, res._0001(), str, null);

                case (FacadeComposer)1:
                    if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
                    {
                        containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, res._0002(), str + ". Skipping serializing self referenced value."), null);
                    }
                    return(false);

                case (FacadeComposer)2:
                    if (containerProperty != null && containerProperty._0001() >= TraceLevel.Verbose)
                    {
                        containerProperty._0001(TraceLevel.Verbose, QueueError.ComputeError(null, res._0002(), str + ". Serializing self referenced value."), null);
                    }
                    return(true);
                }
            }
            return(true);
        }
        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);
        }
        private bool RunClass(SparklineAxisMinMaxValues spec, ProcTest caller, ProductInstanceExpression field, InitializerTest connection2, ProductInstanceExpression selection3)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            SparklineAxisMinMaxValues first = field?._0001() ?? selection3?._0002() ?? connection2?._0001() ?? baseProperty.m_ParserError;

            if (CheckClass(first, spec))
            {
                return(true);
            }
            if (CheckClass(first, (SparklineAxisMinMaxValues)4))
            {
                if (field != null)
                {
                    if (caller._InstanceProperty != field._0001()._0003())
                    {
                        return(true);
                    }
                }
                else if (connection2 != null)
                {
                    if (connection2._0001() == null || caller._InstanceProperty != connection2._0001()._0003())
                    {
                        return(true);
                    }
                }
                else if (_VisitorProperty != null && wrapperProperty.Count == globalProperty)
                {
                    ProcTest procTest = baseProperty.listenerError._0001(_VisitorProperty);
                    if (caller._InstanceProperty != procTest._0003())
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
        private bool?PrintBroadcaster(ProcTest v, ProductInstanceExpression cfg, InitializerTest serv, ProductInstanceExpression param2)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            bool?result = null;

            if (cfg != null)
            {
                result = cfg._0001();
            }
            if (!result.HasValue && param2 != null)
            {
                result = param2._0002();
            }
            if (!result.HasValue && serv != null)
            {
                result = serv._0001();
            }
            if (!result.HasValue)
            {
                result = v._0002();
            }
            return(result);
        }
        private void InvokeBroadcaster(RecordClassDispatcher last, object b, ProcTest proc, ProductInstanceExpression second2, InitializerTest second3, ProductInstanceExpression vis4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (b == null)
            {
                last._0008();
                return;
            }
            BroadcasterError broadcasterError = second2?._0001() ?? vis4?._0002() ?? second3?._0001() ?? proc._0002() ?? baseProperty.CloneComposer(proc._0002()) ?? proc._0003();

            if (broadcasterError != null && broadcasterError._0001())
            {
                DisableClass(last, broadcasterError, b, proc, second3, vis4);
                return;
            }
            switch (proc._ErrorProperty)
            {
            case (ParameterFilterResolver)1:
                DefineBroadcaster(last, b, (PrototypeFilterResolver)proc, second2, second3, vis4);
                break;

            case (ParameterFilterResolver)2:
            {
                MessageTest messageTest = (MessageTest)proc;
                if (!messageTest._0001())
                {
                    VerifyClass(last, (IEnumerable)b, messageTest, second2, second3, vis4);
                }
                else
                {
                    PatchClass(last, (Array)b, messageTest, second2, second3, vis4);
                }
                break;
            }

            case (ParameterFilterResolver)3:
                ConcatBroadcaster(last, b, (ProccesorClassSpec)proc, second2, second3, vis4);
                break;

            case (ParameterFilterResolver)4:
                SetupBroadcaster(last, b, (StubIteratorMapping)proc);
                break;

            case (ParameterFilterResolver)5:
            {
                ParamClientBridge paramClientBridge = (ParamClientBridge)proc;
                IDictionary       dictionary        = b as IDictionary;
                IDictionary       attr;
                if (dictionary == null)
                {
                    IDictionary dictionary2 = paramClientBridge.CountClient(b);
                    attr = dictionary2;
                }
                else
                {
                    attr = dictionary;
                }
                CompareClass(last, attr, paramClientBridge, second2, second3, vis4);
                break;
            }

            case (ParameterFilterResolver)6:
                ResolveClass(last, (IDynamicMetaObjectProvider)b, (ProducerProperty)proc, second2, second3, vis4);
                break;

            case (ParameterFilterResolver)7:
                OrderClass(last, (ISerializable)b, (CollectionProperty)proc, second2, second3, vis4);
                break;

            case (ParameterFilterResolver)8:
                ((ParserFilterResolver)b)._0001(last, baseProperty._0001().ToArray());
                break;
            }
        }