class quadrant_iterator : public rectangle_iterator
{
public:
    quadrant_iterator()
        : rectangle_iterator(coord_def(0,0),
                             coord_def(LOS_MAX_RANGE, LOS_MAX_RANGE))
    {
    }
};

   for (int x = 0; x <= LOS_MAX_RANGE; x++)
       for (int y = 0; y <= LOS_MAX_RANGE; y++)
           delete los_blockrays[x][y];

   for (quadrant_iterator qi; qi; qi++)
       delete los_blockrays(*qi);

    for (int x = 0; x <= LOS_MAX_RANGE; ++x)
        for (int y = 0; y <= LOS_MAX_RANGE; ++y)
        {
            full_los_blockrays[x][y] = new bit_array(num_cellrays);
            los_blockrays[x][y] = new bit_array(num_nondupe_rays);
        }

    for (quadrant_iterator qi; qi; qi++)
    {
        full_los_blockrays(*qi) = new bit_array(num_cellrays);
        los_blockrays(*qi) = new bit_array(num_nondupe_rays);
    }

    for (int x = 0; x <= LOS_MAX_RANGE; ++x)
        for (int y = 0; y <= LOS_MAX_RANGE; ++y)
            for (int i = 0; i < num_nondupe_rays; ++i)
                los_blockrays[x][y]->set(i,
                    full_los_blockrays[x][y]->get(nondupe_cellrays[i]));

    for (quadrant_iterator qi; qi; qi++)
        for (int i = 0; i < num_nondupe_rays; ++i)
            los_blockrays(*qi)->set(i, full_los_blockrays(*qi)
                                       ->get(nondupe_cellrays[i]));

    for (int x = 0; x <= LOS_MAX_RANGE; ++x)
        for (int y = 0; y <= LOS_MAX_RANGE; ++y)
            delete full_los_blockrays[x][y];

    for (quadrant_iterator qi; qi; qi++)
        delete full_los_blockrays(*qi);

    for (quadrant_iterator qi; qi; qi++)
    {
        coord_def p = coord_def(sx*(qi->x), sy*(qi->y));
        if (!dat.los_bounds(p))
            continue;

    for (int x = 0; x <= LOS_MAX_RANGE; ++x)
        for (int y = 0; y <= LOS_MAX_RANGE; ++y)

        // if this cell is opaque...
        switch (dat.opacity(p))

            coord_def p = coord_def(sx*x, sy*y);
            if (!dat.los_bounds(p))
                continue;
            // if this cell is opaque...
            switch (dat.opacity(p))
            {
            case OPC_OPAQUE:
                // then block the appropriate rays
                *dead_rays |= *los_blockrays[x][y];
                break;
            case OPC_HALF:
                // block rays which have already seen a cloud
                *dead_rays  |= (*smoke_rays & *los_blockrays[x][y]);
                *smoke_rays |= *los_blockrays[x][y];
                break;
            default:
                break;
            }

        case OPC_OPAQUE:
            // then block the appropriate rays
            *dead_rays |= *los_blockrays(*qi);
            break;
        case OPC_HALF:
            // block rays which have already seen a cloud
            *dead_rays  |= (*smoke_rays & *los_blockrays(*qi));
            *smoke_rays |= *los_blockrays(*qi);
            break;
        default:
            break;

    }