function int [ ] GetPrimsFromEdge ( int input; int pt0; int pt1 )
{
    int prims [ ];
    int hedge = pointedge ( input, pt0, pt1 );
    if ( hedge != -1 )
    {
        int count = hedge_equivcount ( input, hedge );
        for ( int i = 0; i < count; ++i )
        {
            int pr = hedge_prim ( input, hedge );
            if ( pr != -1 )
            {
                append ( prims, pr );
                hedge = hedge_nextequiv ( input, hedge );
            }
        }
    }
    return prims;
}



int GetNextPoint ( int input; int edgept0; int edgept1; int currentpt )
{
    int ptneighbours [ ] = neighbours ( input, currentpt );
    
    int primpts [ ];
    int prims [ ] = GetPrimsFromEdge ( input, edgept0, edgept1 );
    for ( int i = 0; i < len ( prims ); ++i )
    {
        int count = primvertexcount ( input, prims [ i ] );
        for ( int f = 0; f < count; ++f )
        {
            int vertIndex = vertexindex ( input, prims [ i ], f );
            int pointIndex = vertexpoint ( input, vertIndex );
            append ( primpts, pointIndex );
        }
    }
    
    int uniquepts [ ];
    foreach ( int pt; ptneighbours )
    {
        if ( find ( primpts, pt ) < 0 )
            append ( uniquepts, pt );
    }
    
    if ( len ( uniquepts ) == 1 )
        return uniquepts [ 0 ];

    return -1;
}



void GroupEdgeLoops ( int input; string edgegroup, groupname )
{
    if ( edgegroup == "" )
    {
        setedgegroup ( geoself ( ), groupname, 0, 0, 0 );
        return;
    }
        
    int loopedgepts [ ] = { };
    int edges [ ] = expandedgegroup ( input, edgegroup );
    if ( len ( edges ) == 0 )
    {
        setedgegroup ( geoself ( ), groupname, 0, 0, 0 );
        return;
    }
        
    int count = int ( 0.5 * len ( edges ) );
    for ( int i = 0; i < count; ++i )
    {
        int edgepts [ ] = sort ( array ( edges [ 2 * i ], edges [ 1 + 2 * i ] ) );
        
        int index0 = find ( loopedgepts, edgepts [ 0 ] );
        int index1 = find ( loopedgepts, edgepts [ 1 ] );
        int edgefound = index0 % 2 == 0 && index1 % 2 == 1 && index1 == 1 + index0;
        if ( !edgefound )
        {
            for ( int c = 0; c < 2; ++c )
            {
                int points [ ];
                int pt0 = edgepts [ c ];
                int pt1 = edgepts [ 1 - c ];
                int currentpt = pt0;
                int lastPoint = pt0;
                append ( points, currentpt );
                int nextPoint = GetNextPoint ( input, pt0, pt1, currentpt );
                while ( nextPoint != -1 && nextPoint != lastPoint )
                {
                    pt0 = currentpt;
                    pt1 = nextPoint;
                    currentpt = pt1;
                    append ( points, currentpt );
                    nextPoint = GetNextPoint ( input, pt0, pt1, currentpt );
                }
                
                int ptcount = len ( points ) - 1;
                for ( int f = 0; f < ptcount; ++f )
                    setedgegroup ( geoself ( ), groupname, points [ f ], points [ 1 + f ], 1 );
            }
            setedgegroup ( geoself ( ), groupname, edgepts [ 0 ], edgepts [ 1 ], 1 );
        }
    }
}

GroupEdgeLoops ( 0, chs("group"), chs("vex_selectiongroup") );