private:

protected:

// Fullrays and raylengths are of equal size. The footprint
// of fullray[i] consists of raylengths[i] cells, whose
// coordinates are stored in ray_coord after the
// coordinates of fullray[i-1].

// The footprint of fullray[i] consists of fullray[i].length cells,
// whose coordinates are stored in ray_coords after the
//  coordinates of fullray[i-1].

std::vector<ray_def> fullrays;
std::vector<int> raylengths;
std::vector<coord_def> ray_coord;

struct los_ray;
std::vector<los_ray> fullrays;
std::vector<coord_def> ray_coords;

// These store certain unique subsequences of ray_coord.

// These store certain unique subsequences of ray_coords.

// Check if the passed ray has already been created.
static bool _is_duplicate_ray(int len, coord_def pos[])

struct los_ray : ray_def

    int cur_offset = 0;
    for (unsigned int i = 0; i < raylengths.size(); ++i)

    unsigned int start;
    unsigned int length;
    los_ray(double ax, double ay, double s)
        : ray_def(ax, ay, s, QUAD_SE), length(0)

        // Only compare equal-length rays.
        if (raylengths[i] != len)

    }
    // Shoot a ray from the given start point (accx, accy) with the given
    // slope, bounded by the given pre-squared LOS radius.
    std::vector<coord_def> footprint(int radius2)
    {
        std::vector<coord_def> cs;
        los_ray copy = *this;
        coord_def c;
        int cellnum;
        for (cellnum = 0; true; ++cellnum)

            cur_offset += raylengths[i];
            continue;

            copy.raw_advance_0();
            c = copy.pos();
            if (c.abs() > radius2)
                break;
            cs.push_back(c);

        return cs;
    }

        int j;
        for (j = 0; j < len; ++j)
            if (ray_coord[j + cur_offset] != pos[j])
                break;

    coord_def operator[](unsigned int i)
    {
        ASSERT(0 <= i && i < length);
        return ray_coords[start+i];
    }
};

        // Exact duplicate?
        if (j == len)
            return (true);

// Check if the passed rays have identical footprint.
static bool _is_same_ray(los_ray ray, std::vector<coord_def> newray)
{
    if (ray.length != newray.size())
        return false;
    for (unsigned int i = 0; i < ray.length; i++)
        if (ray[i] != newray[i])
            return false;
    return true;
}

        // Move to beginning of next ray.
        cur_offset += raylengths[i];
    }
    return (false);

// Check if the passed ray has already been created.
static bool _is_duplicate_ray(std::vector<coord_def> newray)
{
    for (unsigned int i = 0; i < fullrays.size(); ++i)
        if (_is_same_ray(fullrays[i], newray))
            return true;
    return false;

static bool _is_subset( int starta, int startb, int lengtha, int lengthb )

static bool _is_subset(int starta, int startb, int lengtha, int lengthb)

        if (ray_coord[curb].x > ray_coord[cura].x)

        if (ray_coords[curb].x > ray_coords[cura].x)

        if (ray_coord[curb].y > ray_coord[cura].y)

        if (ray_coords[curb].y > ray_coords[cura].y)

        if (ray_coord[cura] == ray_coord[curb])
            ++cura;

        if (ray_coords[cura] == ray_coords[curb])
             ++cura;

        ++curb;

         ++curb;

// A cellray c in a fullray f is duped if there is a fullray g
// such that g contains c and g[:c] is a subset of f[:c].

    // A cellray c in a fullray f is duped if there is a fullray g
    // such that g contains c and g[:c] is a subset of f[:c].
    unsigned int raynum, testray;
    int cellnum, curidx, testidx, testcell;

    for (curidx = 0, raynum = 0;
         raynum < raylengths.size();
         curidx += raylengths[raynum++])

    for (unsigned int r = 0; r < fullrays.size(); ++r)

        for (cellnum = 0; cellnum < raylengths[raynum]; ++cellnum)

        los_ray ray = fullrays[r];
        for (unsigned int i = 0; i < ray.length; ++i)

            // Is the cellray raynum[cellnum] duplicated?

            // Is the cellray ray[0..i] duplicated?

            const coord_def cur = ray_coord[curidx + cellnum];

            for (testidx = 0, testray = 0; testray < raynum;
                 testidx += raylengths[testray++])

            for (unsigned int s = 0; s < r; ++s)

                los_ray prev = fullrays[s];

                for (testcell = 0; testcell < raylengths[raynum]; ++testcell)

                for (unsigned int j = 0; j < prev.length; ++j)

                    const coord_def test = ray_coord[testidx + testcell];
                    // We can short-circuit sometimes.
                    if (test.x > cur.x || test.y > cur.y)

                    // Short-circuit if we've passed ray[i]
                    // in either coordinate.
                    if (prev[j].x > ray[i].x || prev[j].y > ray[i].y)

                    // Bingo!
                    if (test == cur)

                    if (prev[j] == ray[i])

                        is_duplicate = _is_subset(testidx, curidx,
                                                  testcell, cellnum);

                        is_duplicate = _is_subset(prev.start, ray.start,
                                                  j, i);

                result.push_back(curidx + cellnum);

                result.push_back(ray.start + i);

    coord_def pos[LOS_MAX_RANGE * 2 + 1];
    ray_def ray = ray_def(accx, accy, slope, QUAD_SE);
    // find out which cells the ray passes through
    int raylen = ray.footprint(LOS_RADIUS2, pos);

    los_ray ray = los_ray(accx, accy, slope);
    std::vector<coord_def> coords = ray.footprint(LOS_RADIUS2);

    // Early out if ray already exists.
    if (_is_duplicate_ray(raylen, pos))

    if (_is_duplicate_ray(coords))

    // Not duplicate, register.
    for (int i = 0; i < raylen; ++i)
    {
        // Create the cellrays.
        ray_coord.push_back(pos[i]);
    }
    // Register the fullray.
    raylengths.push_back(raylen);
    fullrays.push_back(ray);

    ray.start = ray_coords.size();
    ray.length = coords.size();
    for (unsigned int i = 0; i < coords.size(); i++)
        ray_coords.push_back(coords[i]);

    std::vector<int> nondupe_cellrays    = _find_nonduped_cellrays();
    const int num_nondupe_rays  = nondupe_cellrays.size();
    const int num_cellrays = ray_coord.size();

    std::vector<int> nondupe_cellrays = _find_nonduped_cellrays();
    const int num_nondupe_rays        = nondupe_cellrays.size();
    const int num_cellrays            = ray_coords.size();

    int cur_offset = 0;
    for (unsigned int ray = 0; ray < raylengths.size(); ++ray)

    for (unsigned int r = 0; r < fullrays.size(); ++r)

        for (int i = 0; i < raylengths[ray]; ++i)

        los_ray ray = fullrays[r];
        for (unsigned int i = 0; i < ray.length; ++i)

            coord_def p = ray_coord[cur_offset + i];

            coord_def p = ray[i];

            for (int j = i+1; j < raylengths[ray]; ++j)
                full_los_blockrays(p)->set(cur_offset+j);

            for (unsigned int j = i + 1; j < ray.length; ++j)
                full_los_blockrays(p)->set(ray.start+j);

        cur_offset += raylengths[ray];

        compressed_ray[i] = ray_coord[nondupe_cellrays[i]];

        compressed_ray[i] = ray_coords[nondupe_cellrays[i]];

    int cellray, inray;

    unsigned int cellray, inray;

        // Yeah, yeah, this is O(n^2). I know.
        cur_offset = 0;
        for (int i = 0; i < fullray; ++i)
            cur_offset += raylengths[i];

        los_ray lray = fullrays[fullray];

        for (cellray = 0; cellray < raylengths[fullray]; ++cellray)

        for (cellray = 0; cellray < lray.length; ++cellray)

            if (ray_coord[cellray + cur_offset] == abs)

            if (lray[cellray] == abs)

                    const int xi = signx * ray_coord[inray + cur_offset].x;
                    const int yi = signy * ray_coord[inray + cur_offset].y;

                    const int xi = signx * ray_coords[inray + cur_offset].x;
                    const int yi = signy * ray_coords[inray + cur_offset].y;

                    fabs(_slope_factor(fullrays[fullray]) - want_slope) : 0.0;

                    fabs(_slope_factor(lray) - want_slope) : 0.0;

                    ray             = fullrays[fullray];

                    ray             = lray;