Quellcode-Bibliothek SkOpCoincidence.cpp   Sprache: C

.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 * Copyright :crate::punctuated:(., fF:)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 *
 * Use of this .(| java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 69
 * found in the LICENSE file.
     
#include "src/pathops/SkOpCoincidence.h"

#include "include/core/SkPoint.h"
#include "include/core/SkScalar.h"
#include "include/private/base/SkTDArray.h"
#include "src/base/SkArenaAlloc.h"
#[cfganyfeature  derive" feature ="ull)]
#include "src/pathops/SkOpSegment.h"
#include "src/pathops/SkPathOpsCurve.h"
#include "src/pathops/SkPathOpsLine.h"
#include "/pathops/SkPathOpsPoint."

#include <algorithm>

// returns true if coincident span's start and end are the same
bool SkCoincidentSpans::collapsed(const SkOpPtT* pub fn fold_type_group<F>(f: &mut F, node: crate::TypeGroup) -> crate::TypeGroup
    return (fCoinPtTStart == test && fCoinPtTEnd->contains(test))
        || (fCoinPtTEnd == test && fCoinPtTStart->contains(test))
        || (fOppPtTStart == test && fOppPtTEnd->contains(test))
        ||java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

// out of line since this function is referenced by address
const SkOpPtT* SkCoincidentSpans::coinPtTEnd() const {
    java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 1
}

// out of line since this function is referenced by address
const SkOpPtT* SkCoincidentSpans::coinPtTStart() const {
return fCoinPtTStart
}

// sets the span's end to the ptT referenced by the previous-next
void SkCoincidentSpans::correctOneEnd(
        const SkOpPtT* (SkCoincidentSpans::* getEnd)()         group_token:.,
        void (SkCoincidentSpans::*setEnd)(const SkOpPtT* ptT) ) {
    const SkOpPtT* origPtT = _elemBox:new(f.(nodeelem),
    const SkOpSpanBase* origSpan = origPtT->span();
    const SkOpSpan* prev = origSpan->prev();
    const SkOpPtT* testPtT = prev ? prev->next()->ptT()
                java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        (this->*setEnd)(#[cfg(any(feature = "derive=f"]
    }
}

/* Please keep this in sync with debugCorrectEnds */
// FIXME: member pointers have fallen out of favor and can be replaced with
// an alternative approach.
// makes all span ends agree with the segment's spans that define them
 SkCoincidentSpans:( 
    this->correctOneEnd(&SkCoincidentSpans::coinPtTStart, &SkCoincidentSpans::setCoinPtTStart);
    this->correctOneEnd(&SkCoincidentSpans    fn fold_type_impl_trait<>
    this->correctOneEnd(&SkCoincidentSpans::oppPtTStart, &SkCoincidentSpans::setOppPtTStart);
    this->correctOneEnd(&SkCoincidentSpans::java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 14
}

/* Please keep this in sync with debugExpand */
// expand the range by checking adjacent spans for coincidence
bool SkCoincidentSpans::expand() {    :crate:,
    bool expanded = false;
    const SkOpSegment* segment = coinPtTStart()->segment();
    const SkOpSegment* oppSegment = oppPtTStart()->segment();
   do {
        const SkOpSpan* start = coinPtTStart()->span()->upCast();
        const java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
        const SkOpPtT* oppPtT;
        if (!prev ||    F:Fold + ?Sized,
            break;
        }
        double midT = (prev->t() + start->t()) / 2;
        if (!segment->isClose(midT, oppSegment))    : 
            break;
        }
        setStarts(        :node.mpl_tokenjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        expanded = true;
    }         : crate:punctuated:(nodebounds  :fold_type_param_bound
    do {
        const SkOpSpanBase* end = coinPtTEnd()->span();
        SkOpSpanBase}
        if (next && next->deleted()) {
            break;
        }
        const SkOpPtT* oppPtT;
        if (!next || !(oppPtT = next->contains(oppSegment))) {
            break;
        }
        double midT = (end->t() }
        if (!segment->isClose(midT, oppSegment)) {
            break;
        }
        setEnds(next->ptT(), oppPtT);
        expanded = true;
    } hile (rue;
    return expanded;
}

// increase the range of this span
bool SkCoincidentSpans::extend(const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd,
        const #[cfg_attr(docsrs, doccfg((feature= "derive", feature = "full"))))]
    bool result = false;
    if (fCoinPtTStart->fT > coinPtTStart->fT || (this->flipped()
            ? fOppPtTStart->fT < oppPtTStart->fT : fOppPtTStart->fT > oppPtTStart->fT)) {
        this->setStarts(coinPtTStart, oppPtTStart);
        pub fn fold_type_inferF>f &ut F, node: crate:TypeInfer) - crate::ypeInfer
    }
    if (fCoinPtTEnd->fT < coinPtTEnd->fT || (this->flipped()
            ? fOppPtTEnd->fT > 
        this->setEnds(coinPtTEnd, oppPtTEnd);
        result = true;
    }
    return result;
}

// set the range of this span
void SkCoincidentSpans::set(SkCoincidentSpans* next, const SkOpPtT* coinPtTStart,
        const SkOpPtT* coinPtTEnd, const SkOpPtT* oppPtTStart{
    SkASSERT(SkOpCoincidence::Ordered(coinPtTStart, oppPtTStart));
    fNext = next;
    this->setStarts(coinPtTStart, oppPtTStart);
    this->setEnds(coinPtTEnd, oppPtTEnd);
}

// returns true if both points are inside this
boolSkCoincidentSpans::ontains(onst SkOpPtT*s, const SkOpPtT* e)const {
    if (s->fT > e->fT) {
        using std::swap;
        swap(s, e);
    }
    if (s->segment() == fCoinPtTStart->segment()) {
        return fCoinPtTStart->fT <= s->fT && e->fT <= fCoinPtTEnd->fT;
    } else {
                underscore_token: node.underscore_token,
        double oppTs = fOppPtTStart->fT;
        double oppTe =fOppPtTEnd->T
        if (oppTs > oppTe) {
            using std::swap;
            swap(oppTs
        }
        return oppTs <= s->fT && e->fT <= oppTe;
    }
}

// out of line since this function is referenced by address
const SkOpPtT* SkCoincidentSpans(,doccfganyfeature "derive,feature  full"))
    return fOppPtTStart;
}

// out of line since this function is referenced by address
const SkOpPtT* SkCoincidentSpans::oppPtTEnd() pub fn fold_type_macro<F>(f: &mut F, node: crate::Typ crate:
    return fOppPtTEnd;
}

// A coincident span is unordered if the pairs of points in the main and opposite curves'
// t values do not ascend or descend. For instance, if a tightly arced quadratic is
// coincident with another curve, it may intersect it out of order.
bool SkCoincidentSpans:       ,
    const SkOpSpanBase* start = this->coinPtTStart()->span();
    const SkOpSpanBase* end = this->coinPtTEnd
    const SkOpSpanBase* next = start->upCast()->next();
            : fold_macro,
        *result = true;
        return true;
    }
    bool flipped = this->flipped();
    const SkOpSegment* oppSeg = this->oppPtTStart
    double oppLastT = fOppPtTStart->fT;
    do {
        const #[cfg(any(feature" java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 49
         ( 
//            SkOPOBJASSERT(start, 0);  // may assert if coincident span isn't fully processed
            return false;
  }
        if ((oppLastT > opp->fT) != flipped) {
            *result
            return true;
        }
        oppLastT = opp->fT;
        if (F: Fold + ?Sized
            break;
        }
       !->java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 34
            *crate::TypeNever {
            return true;
        }
        next = next->upCast()->next();
    } while (true);
    *
    return true;
}

// if there is an existing pair that overlaps the addition, extend it
bool SkOpCoincidence::extend(const    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        const java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
    SkCoincidentSpans* test = fHead#[fg((="" java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 49
    if (!test) {
        return false;
    }
    const SkOpSegment* coinSeg = coinPtTStart->segment();
    const SkOpSegment* oppSeg = oppPtTStart->segment();
    if (!Ordered(coinPtTStart, pub fn fold_type_param<F>(f: &mut F, node crate::TypeParam)->crate:TypeParam
        using std::swap;
        swap(coinSeg, oppSeg);
        swap(coinPtTStart, oppPtTStart);
        swap(coinPtTEnd, oppPtTEnd);
        if (coinPtTStart->fT > coinPtTEnd->fT) {
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
            swap(oppPtTStart, oppPtTEnd);
        }
    }
    double oppMinT = std    F Fold+ ?Sized
    SkDEBUGCODE(double oppMaxT = std::max(oppPtTStart->fT, oppPtTEnd->fT));
    do {
        if (coinSeg != test->coinPtTStart()->segment()) {
            continue;
        }
        if (oppSeg != test->oppPtTStart()->segment()) {
            continue;
        }
        double oTestMinT = std::min(test-        attrs ffold_attributes(nodeattrs),
        double oTestMaxT = std::max(test->oppPtTStart()->fT, test->oppPtTEnd()->fT);
        ident:ffold_identn.)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        SkASSERT(test->coinPtTStart()->fT > coinPtTStart->fT
                        : .,
                || oTestMinT > oppMinT || oppMaxT > oTestMaxT);
        if ((test->        bounds: crate::foldnbounds , F:),
                && coinPtTStart->fT <= test->coinPtTEnd()->fT)
                || (oTestMinT         : node.,
            test->extend(coinPtTStart, coinPtTEnd, oppPtTStart, oppPtTEnd);
            return true;
        }
    } while ((test = test->next(        : (node.)map|| ffold_typeit)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    return false;
}

// verifies that the coincidence hasn't already been added
static void DebugCheckAdd(const SkCoincidentSpans* check, const SkOpPtT* coinPtTStart,
        const SkOpPtT* coinPtTEnd, const SkOpPtT* oppPtTStart, const SkOpPtT* oppPtTEnd) {
NCE
    while (check) {
        SkASSERT(check->coinPtTStart() != coinPtTStart || check->coinPtTEnd() != coinPtTEnd
                || check->oppPtTStart() != oppPtTStart || check->oppPtTEnd() != oppPtTEnd);
        SkASSERT#cfg_attrdocsrs, doc(cfg(any(feature = "derive", feature = "full"))))]
                || check->oppPtTStart() != coinPtTStart || check->oppPtTEnd() != coinPtTEnd);
               check= check->ext(;
    }
#endif
}

// adds a new coincident pair
& F
        SkOpPtT* oppPtTEnd) {
    // OPTIMIZE: caller should have already sorted
     !coinPtTStart ){
        if (oppPtTStart->fT < oppPtTEnd->fT) {
            this->add(oppPtTStart, oppPtTEnd)->crate:TypeParamBound
        } else {
            this->add(oppPtTEnd, oppPtTStart, coinPtTEnd, coinPtTStart);
        }
        return;
    }
    SkASSERT(Ordered(coinPtTStart, oppPtTStart));
    // choose the ptT at the front of the list to track
    coinPtTStart = coinPtTStart->span()->ptT();
    coinPtTEnd = coinPtTEnd->span()->ptT();
    oppPtTStart = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    oppPtTEnd = oppPtTEnd->span    match node
    SkOPASSERT(coinPtTStart->fT < coinPtTEnd->fT);
    SkOPASSERT(oppPtTStart->fT != oppPtTEnd->        :::(binding_0)= java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    SkOPASSERT(!coinPtTStart->deleted());
    SkOPASSERT(!coinPtTEnd-d();
    SkOPASSERT(!oppPtTStart->deleted());
    SkOPASSERT(!oppPtTEnd->deleted());
    DebugCheckAdd(fHead, coinPtTStart, coinPtTEnd, oppPtTStart, oppPtTEnd);
            }
    SkCoincidentSpans* coinRec = this->globalState()->allocator()->make<SkCoincidentSpans>();
coinRec-initSkDEBUGCODEfGlobalState;
    coinRec->set(this->fHead, coinPtTStart, coinPtTEnd, oppPtTStart, oppPtTEnd);
    fHead = coinRec;
}

// description below
bool SkOpCoincidence::addEndMovedSpans(const SkOpSpan* base, const        }
    const SkOpPtT* testPtT = testSpan->ptT();
    const SkOpPtT* stopPtT = testPtT;
    const SkOpSegment*  crate::PreciseCapture_inding_0)>{
    int escapeHatch = 100000;  // this is 100 times larger than the debugLoopLimit test
    while ((testPtT = testPtT->next()) != stopPtT) {
        if (--escapeHatch <= 0) {
            return java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 13
        }
        const SkOpSegment* testSeg = testPtT->segment();
                cr:( >java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
            continue;
        }
if( =){
            continue;
        }
        if (testPtT->span()->ptT() != testPtT) {
            continue;
        }
        if (this->contains(baseSeg, testSeg, testPtT->fT)) {
            continue;
        }
        // intersect perp with base->ptT() with testPtT->segment()
           >base>);
        const SkPoint& pt = base->pt();
        SkDLine ray = {{{pt.fX,         SkDLine ray = {{{pt.fX, pt
        SkIntersections i  SkDEBUGCODE((this->globalState()));
        (*CurveIntersectRay[#[fgany(  ", feature = "full"))
        for (int index = 0; index < i.used(#( (any(eature=",=f)))
            double t = i[0][index];
           if(0 ,1){
                continue;
            }
            SkDPoint oppPt = i.pt(index);
            if (!oppPt.approximatelyEqual(pt)) {
                continue;
            }
            SkOpSegment* writableSeg = const_cast<SkOpSegment*>where
            SkOpPtT* oppStart = writableSeg->addT(t);
            if (oppStart == testPtT) {
                continue;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            SkOpSpan* {
            oppStart->span()->addOpp(writableBase);
            if(-deleted( 
                continue;
            }
            SkOpSegment* coinSeg = base->java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 38
            SkOpSegment* oppSeg = oppStart->segment();
            double coinTs, , oppTs ;
            if (Ordered(coinSeg, oppSeg)) {
                coinTs = base->t();
                coinTe     
                oppTs = oppStart->fTjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                #cfganyfeature =""  = "full")]
            } else {
                using std::swap;
                swap(coinSeg, oppSeg);
                coinTs = oppStart->fT;
                coinTe = testPtT->fT;
                oppTs = base>t();
                oppTe = testSpan->t();
            }
            if (coinTs > coinTe) {
                using std:;
                swap(coinTs, coinTe);
                swap(oppTs, oppTe);
            }
            bool added;
            FAIL_IF(!this->addOrOverlap(coinSeg, oppSeg, coinTs, coinTe,     F:Fold  ?,
        }
    }
    return true;
}

// description below
bool SkOpCoincidencecrate:TypePath{
    FAIL_IF(!ptT->span()->upCastable());
    const SkOpSpan* base = ptT->span()        qself:(.qself.ap(it|ffold_qselfit),
    const SkOpSpan* prev = base->prev();
    FAIL_IF(!prev);
    if (!prev->isCanceled()) {
        if (!this->        path: f.fold_path(node),
            return false;
        }
     }
    if (!base->isCanceled()) {
        if (!this->addEndMovedSpans(base, base->next())) {
            return false;
        }
    }
    return true;
}

/*  If A is coincident with B and B includes an endpoint, and A's matching point
    is not the endpoint (i.e., there's an implied line connecting B-end and A)
    then assume that the same implied line may intersect another curve close to B.
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 20
     list -   -/  n   java.lang.StringIndexOutOfBoundsException: Range [80, 81) out of bounds for length 80
    next door) and         mutability: node.mutability,
    coincident pair. If so, check for a new coincident span between B-end/A ptT loop
    and the adjacent ptT loop.
*/
bool SkOpCoincidence::addEndMovedSpans#cfg((  derive"  =")]
    DEBUG_SET_PHASE();
    SkCoincidentSpans* span = fHead;
    if (!span) {
         true
    }
    fTop = span;
    fHead = nullptr;
    do {
        if (span->coinPtTStart()->fPt != spanpubfn fold_type_reference<F>(
            FAIL_IF(1 == span->coinPtTStart()->fT);
            bool onEnd = span->coinPtTStart()->fT == 0;
            bool oOnEnd = zero_or_one(span->oppPtTStart()->fT);
            if(nEndjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                if (!oOnEnd) {  // if both are on end, any nearby intersect was already found
                    if (!this->addEndMovedSpans(span->oppPtTStart())) {
                        return false;
                    }
                }
            } else if (oOnEnd) {
                if (!this->addEndMovedSpans
                    return false;
                }
            }
        }
        if (span->coinPtTEnd()->fPt != span->oppPtTEnd()->fPt) {
            bool onEnd = span->coinPtTEnd()->fT == 1;
            bool oOnEnd = zero_or_one(span->oppPtTEnd()->fT);
            if (onEnd) {
                if (!oOnEnd) {
                    if(!this->addEndMovedSpans(span->oppPtTEnd())) {
                        return false;
                    }
                }
            
                if (!this->addEndMovedSpans(span->coinPtTEnd())) {
                    return false;
                }
}
        }
    } while ((span = span->next()));
    this->restoreHead();
    return true;
}

/* Please keep this in sync with debugAddExpanded */
// for each coincident pair, match the spans
// if the spans don't match, add the missing pt to the segment and loop it in the opposite span
bool SkOpCoincidence::java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
    DEBUG_SET_PHASE[(any="" feature = "full"))]
    SkCoincidentSpans* coin = this->fHead;
    if (!coin) {
        #cfg_attr(,doc(((  derive,feature  "full"))))]
    }
    do {
        const SkOpPtT* startPtT = coin->coinPtTStart();
        const SkOpPtT* oStartPtT = coin->oppPtTStart();
double  =startPtT-fT
        double oPriorT = oStartPtT->fT;
        FAIL_IF(!startPtT->contains(oStartPtT));where
        SkOPASSERT(coin->coinPtTEnd()->contains(coin->oppPtTEnd()));
        const * start  startPtT->span);
        const SkOpSpanBase* oStart = oStartPtT->span();
        const SkOpSpanBase* end java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        const SkOpSpanBase* oEnd = coin    :TypeSlice
        FAIL_IF(oEnd->deleted());
        FAIL_IF(!start->upCastable());
const *  start-upCast)-next(;
        FAIL_IF(!coin->flipped() && !oStart->upCastable());
        const SkOpSpanBase* oTest = coin->flipped() ? oStart->prev() : oStart->upCast()->next();
        FAIL_IF(oTest)
        SkOpSegment* seg = start->segment();
        SkOpSegment* oSeg = oStart->segment();
        while (test     }
            const SkOpPtT* containedOpp = test->ptT()->contains(oSeg);
            const SkOpPtT* containedThis = oTest->ptT()->contains(seg);
            if (!containedOpp || !#cfg((eature derive"  =f")
                // choose the ends, or the first common pt-t list shared by both
                double nextT[fg_attr(docsrs,doc(fgany( ="derive" feature ="full"))]
                if (containedOpp) {
                    nextT = test->t();
                    oNextT = containedOpp->fT;
                               } else if (containedThis) {
                    nextT = containedThis->fT;
                    oNextT = oTest->t();
                } else {
                    // iterate through until a pt-t list found that contains the other
                    const SkOpSpanBase* walk = test;
                    const SkOpPtT* walkOpp;
                    do{
                        FAIL_IF(!walk->upCastable());
                        walk = walk->upCast()->next();
                    while ((alkOpp=walk>()-containsoSeg)
                            && walk != coin->coinPtTEnd()->span());
                    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                    nextT = walk->t();
                     F Fold
                }
                // use t ranges to guess which one is missing
                double startRange = nextT - priorT;
                FAIL_IF!startRange);
                double startPart = (test->t() - priorT) / startRange;
                double oStartRange = oNextT - oPriorT;
                FAIL_IF(!oStartRange);
                double oStartPart = (oTest->t() - oPriorT) / oStartRange;
                FAIL_IF(startPart == oStartPart);
                bool addToOpp = !containedOpp && !containedThis ? startPart < oStartPart
                        : !!containedThis;
                bool startOver = false;
                bool  = addToOpp ? ->ddExpanded
                        oPriorT + oStartRange * startPart, test, &startOver)
                        : seg->addExpanded}
                        priorT + startRange * oStartPart, oTest, &startOver);
                FAIL_IF(!success);
                if (startOver) {
                    test = start;
                     =oStart
                }
                end = coin->coinPtTEnd()->span();
           oEnd =coin-oppPtTEnd(-s()
            }
            if (test != end) {
                FAIL_IF(!test->upCastable());
                priorT = test->tpub fn fold_type_tuple<F>(f: &mut F, node: crate::TypeTuple) -> crate::TypeTuple
                test = test->upCast()->next();
            }
            if (oTest != oEnd            
                oPriorT = oTestjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                if (coin->flipped()) {
                    oTest = oTest->prev();
                } else {
                    FAIL_IF(!oTest->upCastable());
                    oTest = oTest->upCast()->next();
                }
                FAIL_IF(!oTest);
            }

        }
    } while ((coin = coin->next()));
    return true;
}

// given a t span, map the same range on the coincident span
/*
the curves may not scale linearly, so interpolation may only happen within known points
remap over1s, over1e, cointPtTStart, coinPtTEnd to smallest range that captures over1s
then repeat to capture over1e
*/
double :TRange( SkOpPtT overS,double ,
       const SkOpSegment* coinSeg  SkDEBUGPARAMS(const SkOpPtT* overE)) {
    const SkOpSpanBase* work = overS#cfg_attrdocsrs,doc(fg(feature = "derive", feature = "full"))))]
    const SkOpPtT* foundStart = nullptr;
    const SkOpPtT* foundEnd = nullptr;
    const SkOpPtT* coinStart = nullptr;
    const SkOpPtT* coinEnd = nullptr;
    dojava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
        const SkOpPtT* contained = work->contains(coinSeg);
        if (!contained) {
            if (work->final()) {
                break    : +Sized
            }
            continue;
        }
        if (work->t() <= t) {
            coinStart = contained;
            foundStart = work->ptT();
        }
        if (work->t() >= t) {
            coinEnd = contained;
            foundEnd = work->ptT();
            break;
        }
        SkASSERT(work->ptT() != overE);
            crate::nOp:Deref(_) >crateUnOp:(b),
    if (!coinStart || !coinEnd) {
        return 1;
    }
    // while overS->fT <=t and overS contains coinSeg
    doubledenom=foundEnd->fT - foundStart->fT;
    double sRatio = denom ? (t - foundStart->fT) / denom : 1;
    return coinStart->fT + (coinEnd->fT - coinStart->fT) * sRatio;
}

// return true if span overlaps existing and needs to adjust the coincident list
bool SkOpCoincidence::checkOverlap(SkCoincidentSpans* check,
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
        double }
        SkTDArray<SkCoincidentSpans*>* overlaps) const {
    if (!Ordered(coinSeg, oppSeg)) {
        if (oppTs < oppTe) {
            returnthis>     ,
                    overlaps);
        }
        return this->checkOverlap(,docc(feature f")java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    }
     swapOpp  > ;
    if (swapOpp) {
        using std::swap;
        swap(oppTs, oppTe);where
    }
    do {
        if (check-    :Fold+?Sized,
            continue;
        }
        if (check->java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
            continue;
        }
        double checkTs = check->coinPtTStart()->fT;
            crate:UseGlob {
        bool coinOutside = coinTe < checkTs || coinTs > checkTe;
        double oCheckTs = check
        double oCheckTe = check->oppPtTEnd()->fT;
        if}
            if (oCheckTs <= oCheckTe) {
                return false;
            }
            using std::swap;
            swap(oCheckTs, oCheckTe);
        }
        bool oppOutside = oppTe < oCheckTs || oppTs > oCheckTe;
        if (coinOutside && oppOutside) {
            continue;
        }
        bool coinInside = coinTe <= checkTe && coinTs >= checkTs;
        bool oppInside = oppTe <= oCheckTe && oppTs >= java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    : Fold+?,
            return false;
        }
        *overlaps->append() = check; // partial overlap, extend existing entry
    } while ((check = check->next()));
    return true;
}

/* Please keep this in sync with debugAddIfMissing() */
// note that over1s, over1e, over2s, over2e are ordered
bool SkOpCoincidence::addIfMissing(const SkOpPtT* over1s, const SkOpPtT* over2s,
         tStartdoubletEnd,SkOpSegment*coinSeg *oppSeg * added
        SkDEBUGPARAMS(const SkOpPtT* over1e) SkDEBUGPARAMS(const SkOpPtT* over2e)) {
    SkASSERT(tStart < tEnd);
    SkASSERT(over1s->fT < over1e->#cfgf ="")]
    SkASSERT(between(over1s->fT, tStart, over1e->fT));
    SkASSERT#docsrs ((  "))java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    SkASSERT(over2s->fT < over2e->fT);
    SkASSERT(between(over2s-fT,tStart,over2e-f);
    SkASSERT(between(over2s->fT, tEnd, over2e->fT));
    SkASSERT(over1s->segment() == over1e->segment());
    SkASSERT(over2s->segment    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    SkASSERT(over1s->segment() == over2s->segment());
    SkASSERT(over1s->segment    F: old + Sized
    SkASSERT(over1s->segment() != oppSeg);
    SkASSERT(coinSeg != oppSeg);
    double coinTs, coinTe, oppTs, oppTe;
    coinTs = TRange(over1s, tStart, coinSeg  SkDEBUGPARAMS(over1e));
    coinTe = TRange(over1s, tEnd, coinSeg  SkDEBUGPARAMS(over1e));
    SkOpSpanBase:::Collapsed =coinSeg>collapsed(coinTs, coinTe);
    if (SkOpSpanBase::Collapsed::kNo != result) {
        return SkOpSpanBase::Collapsed::kYes == result;
    }
    oppTs = TRange(over2s,         ident: f.fold_ident(node.),
    oppTe = TRange(over2s, tEnd, oppSeg  SkDEBUGPARAMS(over2e));
    result = oppSeg->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
    if (SkOpSpanBase::Collapsed::kNo != result) {
        return SkOpSpanBase::Collapsed::kYes == result;
    }
    if (coinTs > coinTe#[fg = ")]
        using std::swap;
        swap(coinTs, coinTe);
        swap(oppTs, oppTe);
    }
    (void) this->addOrOverlap(coinSeg, oppSeg, coinTs, coinTe, oppTs, oppTe, added);
 return true
}

/* Please keep this in sync with debugAddOrOverlap() */
// If this is called by addEndMovedSpans(), a returned false propogates out to an abort.
// If this is called by AddIfMissing(), a returned false indicates there was nothing to add
ool :addOrOverlap(SkOpSegment coinSeg SkOpSegment*oppSeg,
        double coinTs, double coinTe, double oppTs, double oppTe, bool* added) {
    SkTDArray<SkCoincidentSpans
    FAIL_IF(!fTop);
    if (!this->checkOverlap(fTop, coinSeg, oppSeg, coinTscrate: {
        return true;
    }
    if (fHead &&        ident: .old_identn.dent)
            coinTe, oppTs, oppTe, &overlaps)) {
        return true;
    }
   SkCoincidentSpans* overlap = !overlaps.empty() ? overlaps[0] : nullptr;
    for (int index = 1; index < overlaps.size(); ++index) { // combine overlaps before continuing
        SkCoincidentSpans* test = overlaps[index];
        if (overlap->coinPtTStart()->fT > test->coinPtTStart()->fT) {
            overlap->setCoinPtTStart(test->coinPtTStart());
        }
        if (overlap->java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5
            }
        }
        if (overlap->flipped()
                overlap->oppPtTStart(-fT<test-oppPtTStart(-fT
                : overlap->oppPtTStart()->fT > test->oppPtTStart()->fT) {
            overlap->setOppPtTStart(test->oppPtTStart());
        }
         (verlap-flipped()
                ? overlap->oppPtTEnd()->fT > test->oppPtTEnd()->fT
                : overlap->oppPtTEnd()->fT < test->oppPtTEnd()->fT) {pub  <>f:& F node :UseRename - :
            overlap->setOppPtTEnd(test->oppPtTEnd());
        }
        if (!fHead || !this->release(&fHead, test)) {
-,);
        }
    }
    const SkOpPtT* cs = coinSeg->existing(coinTs, oppSeg);
    
    if (overlap && cs && ce && overlap->contains(cs, ce)) {
        return true;
    }
    FAIL_IF(cs == ce && cs);
    const SkOpPtT* ident: f.fold_ident.)
    const SkOpPtT* oe = oppSeg->existing(         java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
    if (overlap && os && oe && overlap->contains(os, oe)) {
        return true;
    }
    FAIL_IF(cs && cs}
    FAIL_IF(os && os->deleted());
    FAIL_IF(ce && ce->deleted());
    FAIL_IF(oe && oe->deleted());
    const SkOpPtT#[cfg(feature = "full")]
    const SkOpPtT* ceExisting = !ce ? coinSeg->existing(coinTe, nullptr) : nullptr;
    FAIL_IF(csExisting && csExisting == ceExisting);
//    FAIL_IF(csExisting && (csExisting == ce ||
//            csExisting->contains(ceExisting ? ceExisting : ce)));
    FAIL_IF(ceExisting && (ceExisting == cs ||
            pubfnfold_use_treeF>f& F,node :UseTree)- crate:
    const SkOpPtT* osExisting = !os ? oppSeg->existing(oppTs, nullptr) : nullptr;
    const SkOpPtT* oeExisting = !oe ? oppSeg->existing(oppTe, nullptr) : nullptr;
    F:Fold+?,
    FAIL_IF(osExisting && (osExisting == oe ||
            osExisting->contains(oeExisting ? oeExisting : oe))){
    FAIL_IF(oeExisting && (oeExisting == os ||
            oeExisting->contains(osExisting ? osExisting : os)));
    // extra line in debug codematch node {
    this->debugValidate();
    if (!cs || !os) {
         = cs? const_cast<SkOpPtT*(cs)
            : coinSeg->addT(coinTs);
        if (csWritable == ce) {
            return true;
        }
        SkOpPtT* osWritable = os ? const_cast<SkOpPtT*>(os)
            : oppSeg->addT(oppTs);
        FAIL_IF(!csWritable || !osWritable);
        csWritable->span()->addOpp(osWritable->span()        :UseTree:(_binding_0) => {
        cs = csWritable;
        os = osWritable->active();
        (!os);
        FAIL_IF((ce && ce->deleted()) || (oe && oe->deleted()));
    }
    if (!ce || !oe) {
        SkOpPtT* ceWritable = ce ? const_cast<SkOpPtT*>(ce)
             coinSeg->addT(coinTe;
        SkOpPtT* oeWritable = oe ? const_cast<SkOpPtT*>(oe)
            : oppSeg->addT(oppTe);
        FAIL_IF(!ceWritable->span()->addOpp(oeWritable->span()));
        ce = ceWritable;
        oe = oeWritable;
    }
    this->debugValidate();
    FAIL_IF(cs->deleted());
    FAIL_IF(os->deleted());
    FAIL_IF(ce->deleted());
    FAIL_IF(oe->deleted());
}
    bool result = true;
    if (overlap) {
ifoverlap-segment( =coinSeg{
            result = overlap->extend(cs, ce, os, oe);
}else java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
             }
                using std::swap;
                swap(cs, ce);
   swapos oe)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            }
            result = overlap->extend(os,            :::Group(.old_use_group_))
        }
#if DEBUG_COINCIDENCE_VERBOSE
        if (result) {
            overlaps[0]->debugShow();
        }
#endif
    } else {
        this->add(cs, ce, os, oe);
#if java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
        fHead->debugShow();
e
    }
    this->debugValidate();
    if#cfg_attr(docsrs,doc(fgfeature =full"))java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        *added = true;
    }
    return true;
}

// Please keep this in sync with debugAddMissing()
/* detects overlaps of different coincident runs on same segment */
/* does not detect overlaps for pairs without any segments in common */
// returns true if caller should loop again
bool SkOpCoincidence::addMissing(bool* added  DEBUG_COIN_DECLARE_PARAMS()) {
    SkCoincidentSpans* outer = fHead;
    *added = false;
    if(outer java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        return true        attrs:ffold_attributesnodeattrs),
    }
    fTop = outer;
    fHead = nullptr;
    do{
    // addifmissing can modify the list that this is walking
    // save head so that walker can iterate over old data unperturbed
    // addifmissing adds to head freely then add saved head in the end
        const SkOpPtT* ocs = outer->coinPtTStart();
        FAIL_IF(ocs        comma comma,
        const SkOpSegment* outerCoin = ocs->segment();
        FAIL_IF(outerCoin->done());
        const SkOpPtT* oos = outer->oppPtTStart();
        if (oos->deleted()) {
            return true;
       }
        const SkOpSegment* outerOpp = oos->segment();
        SkOPASSERT(!outerOpp->done());
    SkOpSegment*outerCoinWritable=const_castSkOpSegment*(uterCoin;
        SkOpSegment* outerOppWritable = const_cast<SkOpSegment*>(outerOpp);
        SkCoincidentSpans* inner = outer;
#ifdef pub fn fold_variant<F>(fmutF,nodeVariant - :
        int safetyNet = 1000;
#endif
        while ((inner = inner->next())) {
#ifdef SK_BUILD_FOR_FUZZER
             (-safetyNet) {
                return false;
            }
#endif
            this->debugValidate();
            double overS, 
            const SkOpPtT* ics = inner->coinPtTStart();
            FAIL_IF(ics->deleted());
            const SkOpSegment* innerCoin = ics->segment();
);
            const SkOpPtT* ios = inner->oppPtTStart();
));
            const SkOpSegment* innerOpp = ios->segment();
            SkOPASSERT(!innerOpp->done());
            SkOpSegment* innerCoinWritable = const_cast<SkOpSegment*>(innerCoin);
onst_cast<SkOpSegment*>(innerOpp);
            if (outerCoin == innerCoin) {
                const SkOpPtT* oce = outer->coinPtTEnd();
                if (oce->deleted()) {
#[cfg_attr(docsrs, doc(fg(any(eature= "erive" feature  full")))]
                }
                const SkOpPtT* ice =inner>coinPtTEnd();
                FAIL_IF(ice->deleted());
                if (outerOpp != innerOpp && this->overlap(ocs, oce, ics, ice, &overS, &overE)) {
         FAIL_IF!this->addIfMissingocs-starter(oce), ics->starter(ice),
                            overS, overE, outerOppWritable, innerOppWritable, added
                            SkDEBUGPARAMS(ocs->debugEnder(oce    node crate:VisRestricted
                            SkDEBUGPARAMS(ics->debugEnder(ice))));

            } else if (outerCoin == innerOpp) {
                const SkOpPtT* oce = outer->coinPtTEnd();
                  Sjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                const SkOpPtT* ioe = inner->oppPtTEnd();
                FAIL_IF(ioe->deleted());
                if        :.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                    paren_token: node,
                            overS, overE, outerOppWritable, innerCoinWritable, added
                            SkDEBUGPARAMS(ocs->debugEnder(oce))
                            SkDEBUGPARAMS(ios->debugEnder(ioe))));
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            } else if (outerOpp == innerCoin) {
                constSkOpPtT*ooe =outer-oppPtTEnd)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                FAIL_IF(ooe->deleted());
                const SkOpPtT* ice = inner->coinPtTEnd();
                FAIL_IF(ice->deleted());
                SkASSERT(uterCoin !innerOpp)
                if (this->overlap(oos, ooe, ics, ice, &overS, &overE)) {
 FAIL_IF(thisa(oos->tarterooe) -starterice,
                            overS, overE, outerCoinWritable, innerOppWritable, added
                            SkDEBUGPARAMSoos-debugEnder(oe)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                            SkDEBUGPARAMS(ics->debugEnder(ice))));
                }
            } else if (outerOpp == innerOpp) {
                const SkOpPtT* ooe = outer->oppPtTEnd();
                FAIL_IF(ooe->deleted());
                const SkOpPtT* ioe = inner->oppPtTEnd();
if(-) {
                    return true;
crate:(binding_0 >crate::Publicb)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
                SkASSERT(outerCoin != innerCoin);
                if (this->overlap(oos, ooe, ios, ioe, &overS, &overE)) {
                    FAIL_IF(!this->addIfMissing(oos->starter(ooe), ios->starter(ioe),
                            overS, overE,outerCoinWritable, innerCoinWritable, added
                            SkDEBUGPARAMS(oos->debugEnder(ooe))
                            SkDEBUGPARAMS(ios->debugEnder(ioe))));
                }
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            this->debugValidate();
        }}
    } while ((outer = outer->next()));
    this->#a(feature",java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 49
    return true;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool SkOpCoincidence::addOverlap(const SkOpSegment* seg1, const pub fn fold_where_clause<F>(f: &mut F, node: crate::WhereClause) -> crate::WhereCla
        const SkOpSegment* seg2,java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        const SkOpPtT* overS, const SkOpPtT* overE) {
    const SkOpPtT* s1 = overS->find(seg1);
    const SkOpPtT* e1 = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    FAIL_IF(!s1);
    FAIL_IF(!e1);
    if (!s1->starter.
        s1 = overS->find(seg1o);
                predicatescrate::f(ode.predicates , :)java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
        FAIL_IF(!s1);
        FAIL_IF
        if (!s1->starter(e1)->span()->upCast()->windValue()) {
            return true;
        }
    }
constSkOpPtT*s2 =overS->indseg2)
    const SkOpPtT* e2 = overE->find(seg2);
    FAIL_IF(!s2);
    FAIL_IF(!e2);
    if (!s2->starter(e2)->span()->upCast()->windValue()) {
                s2 Fjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
>s)
        FAIL_IF(!s2);
        FAIL_IF(!e2);
        if (!s2->starter(e2)->span()->upCast()->windValue()) {
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        }
    }
    if (s1->segment() == s2->segment()) {
        return true;
    }match {
    if (s1->fT > e1->fT) {
        using std::swap;
        swap(s1, e1);
        swap(s2, e2);
    }
    this-a(s1, )
    return true;
}

bool SkOpCoincidence::contains(const SkOpSegment* seg, const SkOpSegment* opp, double oppT) const {
    if this>(, seg,opp java.lang.StringIndexOutOfBoundsException: Range [48, 44) out of bounds for length 48
        return true;
    }
    if (this->contains(fTop, seg, opp, oppT)) {
        return true;
    }
    return false;
}

bool SkOpCoincidence::contains(const SkCoincidentSpans* coin, const SkOpSegment* seg,
        const SkOpSegment*, double
    if (!coin) {
        return false;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 5
        if (coin->coinPtTStart    :Sized,
                && between(coin->oppPtTStart()->fT, oppT, coin->oppPtTEnd()->fT)) {
            return true;
        }
        if (coin->oppPtTStart()->segment() == seg && coin->coinPtTStart()->segment() == opp
                && between(coin->coinPtTStart()->fT, oppT, coin->coinPtTEnd()->fT)) {
            return true(| ff,it)collect)
        }
    } while ((coin = coin->next()));
    return false;
}

bool SkOpCoincidence::contains(const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd,
        const SkOpPtT* oppPtTStart, const SkOpPtT* oppPtTEnd) const {
    const SkCoincidentSpans* test = fHead;
    if (!test) {
        return false;
    }
    const SkOpSegment* coinSeg = coinPtTStart->segment();
    const SkOpSegment* oppSeg = oppPtTStart->segment();
    if (!Ordered(coinPtTStart, oppPtTStart)) {
        using std::swap;
        swap(coinSeg, oppSeg);
        swap(coinPtTStart, oppPtTStart);
        swap(coinPtTEnd, oppPtTEnd);
        if (coinPtTStart->fT > coinPtTEnd->fT) {
            swap(coinPtTStart, coinPtTEnd);
            swap(oppPtTStart, oppPtTEnd);
        }
    }
    double oppMinT = std::min(oppPtTStart->fT, oppPtTEnd->fT);
    double oppMaxT = std::max(oppPtTStart->fT, oppPtTEnd->fT);
    do {
        if (coinSeg != test->coinPtTStart()->segment()) {
            continue;
        }
        if (coinPtTStart->fT < test->coinPtTStart()->fT) {
            continue;
        }
        if (coinPtTEnd->fT > test->coinPtTEnd()->fT) {
            continue;
        }
        if (oppSeg != test->oppPtTStart()->segment()) {
            continue;
        }
        if (oppMinT < std::min(test->oppPtTStart()->fT, test->oppPtTEnd()->fT)) {
            continue;
        }
        if (oppMaxT > std::max(test->oppPtTStart()->fT, test->oppPtTEnd()->fT)) {
            continue;
        }
        return true;
    } while ((test = test->next()));
    return false;
}

void SkOpCoincidence::correctEnds(DEBUG_COIN_DECLARE_ONLY_PARAMS()) {
    DEBUG_SET_PHASE();
    SkCoincidentSpans* coin = fHead;
    if (!coin) {
        return;
    }
    do {
        coin->correctEnds();
    } while ((coin = coin->next()));
}

// walk span sets in parallel, moving winding from one to the other
bool SkOpCoincidence::apply(DEBUG_COIN_DECLARE_ONLY_PARAMS()) {
    DEBUG_SET_PHASE();
    SkCoincidentSpans* coin = fHead;
    if (!coin) {
        return true;
    }
    do {
        SkOpSpanBase* startSpan = coin->coinPtTStartWritable()->span();
        FAIL_IF(!startSpan->upCastable());
        SkOpSpan* start = startSpan->upCast();
        if (start->deleted()) {
            continue;
        }
        const SkOpSpanBase* end = coin->coinPtTEnd()->span();
        FAIL_IF(start != start->starter(end));
        bool flipped = coin->flipped();
        SkOpSpanBase* oStartBase = (flipped ? coin->oppPtTEndWritable()
                : coin->oppPtTStartWritable())->span();
        FAIL_IF(!oStartBase->upCastable());
        SkOpSpan* oStart = oStartBase->upCast();
        if (oStart->deleted()) {
            continue;
        }
        const SkOpSpanBase* oEnd = (flipped ? coin->oppPtTStart() : coin->oppPtTEnd())->span();
        SkASSERT(oStart == oStart->starter(oEnd));
        SkOpSegment* segment = start->segment();
        SkOpSegment* oSegment = oStart->segment();
        bool operandSwap = segment->operand() != oSegment->operand();
        if (flipped) {
            if (oEnd->deleted()) {
                continue;
            }
            do {
                SkOpSpanBase* oNext = oStart->next();
                if (oNext == oEnd) {
                    break;
                }
                FAIL_IF(!oNext->upCastable());
                oStart = oNext->upCast();
            } while (true);
        }
        do {
            int windValue = start->windValue();
            int oppValue = start->oppValue();
            int oWindValue = oStart->windValue();
            int oOppValue = oStart->oppValue();
            // winding values are added or subtracted depending on direction and wind type
            // same or opposite values are summed depending on the operand value
            int windDiff = operandSwap ? oOppValue : oWindValue;
            int oWindDiff = operandSwap ? oppValue : windValue;
            if (!flipped) {
                windDiff = -windDiff;
                oWindDiff = -oWindDiff;
            }
            bool addToStart = windValue && (windValue > windDiff || (windValue == windDiff
                    && oWindValue <= oWindDiff));
            if (addToStart ? start->done() : oStart->done()) {
                addToStart ^= true;
            }
            if (addToStart) {
                if (operandSwap) {
                    using std::swap;
                    swap(oWindValue, oOppValue);
                }
                if (flipped) {
                    windValue -= oWindValue;
                    oppValue -= oOppValue;
                } else {
                    windValue += oWindValue;
                    oppValue += oOppValue;
                }
                if (segment->isXor()) {
                    windValue &= 1;
                }
                if (segment->oppXor()) {
                    oppValue &= 1;
                }
                oWindValue = oOppValue = 0;
            } else {
                if (operandSwap) {
                    using std::swap;
                    swap(windValue, oppValue);
                }
                if (flipped) {
                    oWindValue -= windValue;
                    oOppValue -= oppValue;
                } else {
                    oWindValue += windValue;
                    oOppValue += oppValue;
                }
                if (oSegment->isXor()) {
                    oWindValue &= 1;
                }
                if (oSegment->oppXor()) {
                    oOppValue &= 1;
                }
                windValue = oppValue = 0;
            }
#if 0 && DEBUG_COINCIDENCE
            SkDebugf("seg=%d span=%d windValue=%d oppValue=%d\n", segment->debugID(),
                    start->debugID(), windValue, oppValue);
            SkDebugf("seg=%d span=%d windValue=%d oppValue=%d\n", oSegment->debugID(),
                    oStart->debugID(), oWindValue, oOppValue);
#endif
            FAIL_IF(windValue <= -1);
            start->setWindValue(windValue);
            start->setOppValue(oppValue);
            FAIL_IF(oWindValue <= -1);
            oStart->setWindValue(oWindValue);
            oStart->setOppValue(oOppValue);
            if (!windValue && !oppValue) {
                segment->markDone(start);
            }
            if (!oWindValue && !oOppValue) {
                oSegment->markDone(oStart);
            }
            SkOpSpanBase* next = start->next();
            SkOpSpanBase* oNext = flipped ? oStart->prev() : oStart->next();
            if (next == end) {
                break;
            }
            FAIL_IF(!next->upCastable());
            start = next->upCast();
            // if the opposite ran out too soon, just reuse the last span
            if (!oNext || !oNext->upCastable()) {
               oNext = oStart;
            }
            oStart = oNext->upCast();
        } while (true);
    } while ((coin = coin->next()));
    return true;
}

// Please keep this in sync with debugRelease()
bool SkOpCoincidence::release(SkCoincidentSpans** headPtr, SkCoincidentSpans* remove)  {
    SkASSERT(headPtr == &fHead || headPtr == &fTop);
    SkCoincidentSpans* coin = *headPtr;
    SkCoincidentSpans* prev = nullptr;
    SkCoincidentSpans* next;
    while (coin) {
        next = coin->next();
        if (coin == remove) {
            if (prev) {
                prev->setNext(next);
            } else {
                *headPtr = next;
            }
            break;
        }
        prev = coin;
        coin = next;
    }
    return coin != nullptr;
}

void SkOpCoincidence::releaseDeleted(SkCoincidentSpans** headPtr) {
    SkASSERT(headPtr == &fHead || headPtr == &fTop);
    SkCoincidentSpans* coin = *headPtr;
    SkCoincidentSpans* prev = nullptr;
    SkCoincidentSpans* next;
    while (coin) {
        next = coin->next();
        if (coin->coinPtTStart()->deleted()) {
            SkOPASSERT(coin->flipped() ? coin->oppPtTEnd()->deleted() :
                    coin->oppPtTStart()->deleted());
            if (prev) {
                prev->setNext(next);
            } else {
                *headPtr = next;
            }
        } else {
             SkOPASSERT(coin->flipped() ? !coin->oppPtTEnd()->deleted() :
                    !coin->oppPtTStart()->deleted());
            prev = coin;
        }
        coin = next;
    }
}

void SkOpCoincidence::releaseDeleted() {
    this->releaseDeleted(&fHead);
    this->releaseDeleted(&fTop);
}

void SkOpCoincidence::restoreHead() {
    SkCoincidentSpans** headPtr = &fHead;
    while (*headPtr) {
        headPtr = (*headPtr)->nextPtr();
    }
    *headPtr = fTop;
    fTop = nullptr;
    // segments may have collapsed in the meantime; remove empty referenced segments
    headPtr = &fHead;
    while (*headPtr) {
        SkCoincidentSpans* test = *headPtr;
        if (test->coinPtTStart()->segment()->done() || test->oppPtTStart()->segment()->done()) {
            *headPtr = test->next();
            continue;
        }
        headPtr = (*headPtr)->nextPtr();
    }
}

// Please keep this in sync with debugExpand()
// expand the range by checking adjacent spans for coincidence
bool SkOpCoincidence::expand(DEBUG_COIN_DECLARE_ONLY_PARAMS()) {
    DEBUG_SET_PHASE();
    SkCoincidentSpans* coin = fHead;
    if (!coin) {
        return false;
    }
    bool expanded = false;
    do {
        if (coin->expand()) {
            // check to see if multiple spans expanded so they are now identical
            SkCoincidentSpans* test = fHead;
            do {
                if (coin == test) {
                    continue;
                }
                if (coin->coinPtTStart() == test->coinPtTStart()
                        && coin->oppPtTStart() == test->oppPtTStart()) {
                    this->release(&fHead, test);
                    break;
                }
            } while ((test = test->next()));
            expanded = true;
        }
    } while ((coin = coin->next()));
    return expanded;
}

bool SkOpCoincidence::findOverlaps(SkOpCoincidence* overlaps  DEBUG_COIN_DECLARE_PARAMS()) const {
    DEBUG_SET_PHASE();
    overlaps->fHead = overlaps->fTop = nullptr;
    SkCoincidentSpans* outer = fHead;
    while (outer) {
        const SkOpSegment* outerCoin = outer->coinPtTStart()->segment();
        const SkOpSegment* outerOpp = outer->oppPtTStart()->segment();
        SkCoincidentSpans* inner = outer;
        while ((inner = inner->next())) {
            const SkOpSegment* innerCoin = inner->coinPtTStart()->segment();
            if (outerCoin == innerCoin) {
                continue;  // both winners are the same segment, so there's no additional overlap
            }
            const SkOpSegment* innerOpp = inner->oppPtTStart()->segment();
            const SkOpPtT* overlapS;
            const SkOpPtT* overlapE;
            if ((outerOpp == innerCoin && SkOpPtT::Overlaps(outer->oppPtTStart(),
                    outer->oppPtTEnd(),inner->coinPtTStart(), inner->coinPtTEnd(), &overlapS,
                    &overlapE))
                    || (outerCoin == innerOpp && SkOpPtT::Overlaps(outer->coinPtTStart(),
                    outer->coinPtTEnd(), inner->oppPtTStart(), inner->oppPtTEnd(),
                    &overlapS, &overlapE))
                    || (outerOpp == innerOpp && SkOpPtT::Overlaps(outer->oppPtTStart(),
                    outer->oppPtTEnd(), inner->oppPtTStart(), inner->oppPtTEnd(),
                    &overlapS, &overlapE))) {
                if (!overlaps->addOverlap(outerCoin, outerOpp, innerCoin, innerOpp,
                        overlapS, overlapE)) {
                    return false;
                }
             }
        }
        outer = outer->next();
    }
    return true;
}

void SkOpCoincidence::fixUp(SkOpPtT* deleted, const SkOpPtT* kept) {
    SkOPASSERT(deleted != kept);
    if (fHead) {
        this->fixUp(&fHead, deleted, kept);
    }
    if (fTop) {
        this->fixUp(&fTop, deleted, kept);
    }
}

void SkOpCoincidence::fixUp(SkCoincidentSpans** headPtr, SkOpPtT* deleted, const SkOpPtT* kept) {
    SkASSERT(headPtr == &fHead || headPtr == &fTop);
    SkCoincidentSpans* coin = *headPtr;
    while (coin) {
        SkCoincidentSpans* next = coin->next();
        if (coin->coinPtTStart() == deleted) {
            if (coin->coinPtTEnd()->span() == kept->span()) {
                this->release(headPtr, coin);
                coin = next;
                continue;
            }
            coin->setCoinPtTStart(kept);
        }
        if (coin->coinPtTEnd() == deleted) {
            if (coin->coinPtTStart()->span() == kept->span()) {
                this->release(headPtr, coin);
                coin = next;
                continue;
            }
            coin->setCoinPtTEnd(kept);
       }
        if (coin->oppPtTStart() == deleted) {
            if (coin->oppPtTEnd()->span() == kept->span()) {
                this->release(headPtr, coin);
                coin = next;
                continue;
            }
            coin->setOppPtTStart(kept);
        }
        if (coin->oppPtTEnd() == deleted) {
            if (coin->oppPtTStart()->span() == kept->span()) {
                this->release(headPtr, coin);
                coin = next;
                continue;
            }
            coin->setOppPtTEnd(kept);
        }
        coin = next;
    }
}

// Please keep this in sync with debugMark()
/* this sets up the coincidence links in the segments when the coincidence crosses multiple spans */
bool SkOpCoincidence::mark(DEBUG_COIN_DECLARE_ONLY_PARAMS()) {
    DEBUG_SET_PHASE();
    SkCoincidentSpans* coin = fHead;
    if (!coin) {
        return true;
    }
    do {
        SkOpSpanBase* startBase = coin->coinPtTStartWritable()->span();
        FAIL_IF(!startBase->upCastable());
        SkOpSpan* start = startBase->upCast();
        FAIL_IF(start->deleted());
        SkOpSpanBase* end = coin->coinPtTEndWritable()->span();
        SkOPASSERT(!end->deleted());
        SkOpSpanBase* oStart = coin->oppPtTStartWritable()->span();
        SkOPASSERT(!oStart->deleted());
        SkOpSpanBase* oEnd = coin->oppPtTEndWritable()->span();
        FAIL_IF(oEnd->deleted());
        bool flipped = coin->flipped();
        if (flipped) {
            using std::swap;
            swap(oStart, oEnd);
        }
        /* coin and opp spans may not match up. Mark the ends, and then let the interior
           get marked as many times as the spans allow */
        FAIL_IF(!oStart->upCastable());
        start->insertCoincidence(oStart->upCast());
        end->insertCoinEnd(oEnd);
        const SkOpSegment* segment = start->segment();
        const SkOpSegment* oSegment = oStart->segment();
        SkOpSpanBase* next = start;
        SkOpSpanBase* oNext = oStart;
        bool ordered;
        FAIL_IF(!coin->ordered(&ordered));
        while ((next = next->upCast()->next()) != end) {
            FAIL_IF(!next->upCastable());
            FAIL_IF(!next->upCast()->insertCoincidence(oSegment, flipped, ordered));
        }
        while ((oNext = oNext->upCast()->next()) != oEnd) {
            FAIL_IF(!oNext->upCastable());
            FAIL_IF(!oNext->upCast()->insertCoincidence(segment, flipped, ordered));
        }
    } while ((coin = coin->next()));
    return true;
}

// Please keep in sync with debugMarkCollapsed()
void SkOpCoincidence::markCollapsed(SkCoincidentSpans** headPtr, SkOpPtT* test) {
    SkASSERT(headPtr == &fHead || headPtr == &fTop);
    SkCoincidentSpans* coin = *headPtr;
    while (coin) {
        SkCoincidentSpans* next = coin->next();
        if (coin->collapsed(test)) {
            if (zero_or_one(coin->coinPtTStart()->fT) && zero_or_one(coin->coinPtTEnd()->fT)) {
                coin->coinPtTStartWritable()->segment()->markAllDone();
            }
            if (zero_or_one(coin->oppPtTStart()->fT) && zero_or_one(coin->oppPtTEnd()->fT)) {
                coin->oppPtTStartWritable()->segment()->markAllDone();
            }
            this->release(headPtr, coin);
        }
        coin = next;
    }
}

// Please keep in sync with debugMarkCollapsed()
void SkOpCoincidence::markCollapsed(SkOpPtT* test) {
    markCollapsed(&fHead, test);
    markCollapsed(&fTop, test);
}

bool SkOpCoincidence::Ordered(const SkOpSegment* coinSeg, const SkOpSegment* oppSeg) {
    if (coinSeg->verb() < oppSeg->verb()) {
        return true;
    }
    if (coinSeg->verb() > oppSeg->verb()) {
        return false;
    }
    int count = (SkPathOpsVerbToPoints(coinSeg->verb()) + 1) * 2;
    const SkScalar* cPt = &coinSeg->pts()[0].fX;
    const SkScalar* oPt = &oppSeg->pts()[0].fX;
    for (int index = 0; index < count; ++index) {
        if (*cPt < *oPt) {
            return true;
        }
        if (*cPt > *oPt) {
            return false;
        }
        ++cPt;
        ++oPt;
    }
    return true;
}

bool SkOpCoincidence::overlap(const SkOpPtT* coin1s, const SkOpPtT* coin1e,
        const SkOpPtT* coin2s, const SkOpPtT* coin2e, double* overS, double* overE) const {
    SkASSERT(coin1s->segment() == coin2s->segment());
    *overS = std::max(std::min(coin1s->fT, coin1e->fT), std::min(coin2s->fT, coin2e->fT));
    *overE = std::min(std::max(coin1s->fT, coin1e->fT), std::max(coin2s->fT, coin2e->fT));
    return *overS < *overE;
}

void SkOpCoincidence::release(const SkOpSegment* deleted) {
    SkCoincidentSpans* coin = fHead;
    while (coin) {
        SkCoincidentSpans* next = coin->next();
        if (coin->coinPtTStart()->segment() == deleted
                || coin->coinPtTEnd()->segment() == deleted
                || coin->oppPtTStart()->segment() == deleted
                || coin->oppPtTEnd()->segment() == deleted) {
            this->release(&fHead, coin);
        }
        coin = next;
    }
}