public static bool TryStepLeft(Link startLink, Link leftLink, Link[] result, int offset)
        {
            int added = 0;

            startLink.WalkThroughReferersByTarget(couple =>
                {
                    if (couple.Linker == Net.And)
                    {
                        var coupleSource = couple.Source;
                        if (coupleSource == leftLink)
                        {
                            result[offset] = couple;
                            if (++added == 2)
                                return Link.Stop;
                        }
                        else if (coupleSource.Linker == Net.And && coupleSource.Target == leftLink)
                        {
                            result[offset + 1] = couple;
                            if (++added == 2)
                                return Link.Stop;
                        }
                    }

                    return Link.Continue;
                });

            return added > 0;
        }
        public static Link[] GetRightElements(Link startLink, Link rightLink)
        {
            var result = new Link[4];

            TryStepRight(startLink, rightLink, result, 0);

            startLink.WalkThroughReferersByTarget(couple =>
                {
                    if (couple.Linker == Net.And)
                        if (TryStepRight(couple, rightLink, result, 2))
                            return Link.Stop;

                    return Link.Continue;
                });

            return result;
        }
        private static Link TryReconstructConnection(Link first, Link second)
        {
            Link directConnection = null;

            if (second.ReferersBySourceCount < first.ReferersBySourceCount)
            {
                //  o_|      x_o ...
                // x_|        |___|
                //
                // <-

                second.WalkThroughReferersBySource(couple =>
                {
                    if (couple.Linker == Net.And && couple.ReferersByTargetCount == 1 && couple.ReferersBySourceCount == 0)
                    {
                        Link neighbour = couple.FirstRefererByTarget;
                        if (neighbour.Linker == Net.And && neighbour.Source == first)
                        {
                            if (directConnection == null)
                                directConnection = first & second;

                            Link.Update(ref neighbour, directConnection, Net.And, couple.Target);
                            //Link.Delete(ref couple); // Можно заменить удалением couple
                        }
                    }

                    if (couple.Linker == Net.And)
                    {
                        Link neighbour = couple.FirstRefererByTarget;
                        if (neighbour.Linker == Net.And && neighbour.Source == first)
                        {

                        }
                    }
                });
            }
            else
            {
                //  o_|     x_o ...
                // x_|       |___|
                //
                // ->

                first.WalkThroughReferersBySource(couple =>
                {
                    if (couple.Linker == Net.And)
                    {
                        Link neighbour = couple.Target;
                        if (neighbour.Linker == Net.And && neighbour.Source == second)
                        {
                            if (neighbour.ReferersByTargetCount == 1 && neighbour.ReferersBySourceCount == 0)
                            {
                                if (directConnection == null)
                                    directConnection = first & second;

                                Link.Update(ref couple, directConnection, Net.And, neighbour.Target);
                                //Link.Delete(ref neighbour);
                            }
                        }
                    }
                });
            }

            if (second.ReferersByTargetCount < first.ReferersByTargetCount)
            {
                // |_x      ... x_o
                //  |_o      |___|
                //
                //   <-

                second.WalkThroughReferersByTarget(couple =>
                {
                    if (couple.Linker == Net.And)
                    {
                        Link neighbour = couple.Source;
                        if (neighbour.Linker == Net.And && neighbour.Target == first)
                        {
                            if (neighbour.ReferersByTargetCount == 0 && neighbour.ReferersBySourceCount == 1)
                            {
                                if (directConnection == null)
                                    directConnection = first & second;

                                Link.Update(ref couple, neighbour.Source, Net.And, directConnection);
                                //Link.Delete(ref neighbour);
                            }
                        }
                    }
                });
            }
            else
            {
                // |_x      ... x_o
                //  |_o      |___|
                //
                //   ->

                first.WalkThroughReferersByTarget((couple) =>
                {
                    if (couple.Linker == Net.And && couple.ReferersByTargetCount == 0 && couple.ReferersBySourceCount == 1)
                    {
                        Link neighbour = couple.FirstRefererBySource;
                        if (neighbour.Linker == Net.And && neighbour.Target == second)
                        {
                            if (directConnection == null)
                                directConnection = first & second;

                            Link.Update(ref neighbour, couple.Source, Net.And, directConnection);
                            Link.Delete(ref couple);
                        }
                    }
                });
            }

            if (directConnection != null)
            {
                CompressionsCount++;
            }

            return directConnection;
        }