int footprint(int radius2, int xpos[], int ypos[]) const;

    int footprint(int radius2, coord_def pos[]) const;

int ray_def::footprint(int radius2, int xpos[], int ypos[]) const

int ray_def::footprint(int radius2, coord_def cpos[]) const

        xpos[cellnum] = curx;
        ypos[cellnum] = cury;

        cpos[cellnum] = coord_def(curx, cury);

// coordinates are stored in ray_coord_{x,y} after the

// coordinates are stored in ray_coord after the

std::vector<short> ray_coord_x;
std::vector<short> ray_coord_y;

std::vector<coord_def> ray_coord;

// These store certain unique subsequences of ray_coord_{x,y}.

// These store certain unique subsequences of ray_coord.

std::vector<short> compressed_ray_x;
std::vector<short> compressed_ray_y;

std::vector<coord_def> compressed_ray;

// the cellray starting at compressed_ray_{x,y}[i].

// the cellray starting at compressed_ray[i].

static bool _is_duplicate_ray(int len, int xpos[], int ypos[])

static bool _is_duplicate_ray(int len, coord_def pos[])

        {
            if (ray_coord_x[j + cur_offset] != xpos[j]
                || ray_coord_y[j + cur_offset] != ypos[j])
            {

            if (ray_coord[j + cur_offset] != pos[j])

            }
        }

        if (ray_coord_x[curb] > ray_coord_x[cura])

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

        if (ray_coord_y[curb] > ray_coord_y[cura])

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

        if (ray_coord_x[cura] == ray_coord_x[curb]
            && ray_coord_y[cura] == ray_coord_y[curb])
        {

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

        }

            const int curx = ray_coord_x[curidx + cellnum];
            const int cury = ray_coord_y[curidx + cellnum];

            const coord_def cur = ray_coord[curidx + cellnum];

                    const int testx = ray_coord_x[testidx + testcell];
                    const int testy = ray_coord_y[testidx + testcell];

                    const coord_def test = ray_coord[testidx + testcell];

                    if (testx > curx || testy > cury)

                    if (test.x > cur.x || test.y > cur.y)

                    if (testx == curx && testy == cury)

                    if (test == cur)

    int xpos[LOS_MAX_RANGE * 2 + 1], ypos[LOS_MAX_RANGE * 2 + 1];

    coord_def pos[LOS_MAX_RANGE * 2 + 1];

    int raylen = ray.footprint(LOS_RADIUS2, xpos, ypos);

    int raylen = ray.footprint(LOS_RADIUS2, pos);

    if (_is_duplicate_ray(raylen, xpos, ypos))

    if (_is_duplicate_ray(raylen, pos))

        ray_coord_x.push_back(xpos[i]);
        ray_coord_y.push_back(ypos[i]);

        ray_coord.push_back(pos[i]);

    const int num_cellrays = ray_coord_x.size();

    const int num_cellrays = ray_coord.size();

            int x = ray_coord_x[cur_offset + i];
            int y = ray_coord_y[cur_offset + i];

            coord_def p = ray_coord[cur_offset + i];

                full_los_blockrays[x][y]->set(cur_offset+j);

                full_los_blockrays(p)->set(cur_offset+j);

    compressed_ray_x.resize(num_nondupe_rays);
    compressed_ray_y.resize(num_nondupe_rays);

    compressed_ray.resize(num_nondupe_rays);

    {
        compressed_ray_x[i] = ray_coord_x[nondupe_cellrays[i]];
        compressed_ray_y[i] = ray_coord_y[nondupe_cellrays[i]];
    }

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

    const coord_def abs = coord_def(absx, absy);

            if (ray_coord_x[cellray + cur_offset] == absx
                && ray_coord_y[cellray + cur_offset] == absy)

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

                    const int xi = signx * ray_coord_x[inray + cur_offset];
                    const int yi = signy * ray_coord_y[inray + cur_offset];

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

    const unsigned int num_cellrays = compressed_ray_x.size();

    const unsigned int num_cellrays = compressed_ray.size();

            const coord_def p = coord_def(sx * compressed_ray_x[rayidx],
                                          sy * compressed_ray_y[rayidx]);

            const coord_def p = coord_def(sx * compressed_ray[rayidx].x,
                                          sy * compressed_ray[rayidx].y);