virtual heptagon *getOrigin() { return NULL; }

virtual cell *gamestart() { return getOrigin()->c7; }

virtual ~hrmap() { }

virtual vector<cell*>& allcells();

virtual void verify() { }

virtual bool link_alt(heptagon *h, heptagon *alt, hstate firststate, int dir);

virtual void extend_altmap(heptagon *h, int levs = default_levs(), bool link_cdata = true);

heptagon *may_create_step(heptagon *h, int direction) {

if(h->move(direction)) return h->move(direction);

return create_step(h, direction);

}

virtual heptagon *create_step(heptagon *h, int direction);

/** reinitialize the map after swapping dimensions */

virtual void reinit() {}

virtual transmatrix relative_matrixh(heptagon *h2, heptagon *h1, const hyperpoint& hint);

virtual transmatrix relative_matrixc(cell *c2, cell *c1, const hyperpoint& hint);

transmatrix relative_matrix(heptagon *h2, heptagon *h1, const hyperpoint& hint) { return relative_matrixh(h2, h1, hint); }

transmatrix relative_matrix(cell *h2, cell *h1, const hyperpoint& hint) { return relative_matrixc(h2, h1, hint); }

virtual transmatrix adj(cell *c, int i) { return adj(c->master, i); }

virtual transmatrix adj(heptagon *h, int i);

transmatrix iadj(cell *c, int i) { cell *c1 = c->cmove(i); return adj(c1, c->c.spin(i)); }

transmatrix iadj(heptagon *h, int d) {

heptagon *h1 = h->cmove(d); return adj(h1, h->c.spin(d));

}

virtual void draw_all();

virtual void draw_at(cell *at, const shiftmatrix& where);

virtual void virtualRebase(heptagon*& base, transmatrix& at);

static constexpr ld SPIN_NOT_AVAILABLE = 1e5;

virtual ld spin_angle(cell *c, int d) { return SPIN_NOT_AVAILABLE; }

virtual transmatrix spin_to(cell *c, int d, ld bonus=0);

virtual transmatrix spin_from(cell *c, int d, ld bonus=0);

virtual double spacedist(cell *c, int i);

virtual bool strict_tree_rules() { return false; }

virtual void find_cell_connection(cell *c, int d);

virtual int shvid(cell *c) { return 0; }

virtual int full_shvid(cell *c) { return shvid(c); }

virtual hyperpoint get_corner(cell *c, int cid, ld cf=3) { return C0; }

virtual transmatrix master_relative(cell *c, bool get_inverse = false) { return Id; }

virtual int wall_offset(cell *c);

virtual transmatrix ray_iadj(cell *c, int i);

virtual subcellshape& get_cellshape(cell *c);

/** \brief in 3D honeycombs, returns a cellwalker res at cw->move(j) such that the face pointed at by cw and res share an edge */

virtual cellwalker strafe(cellwalker cw, int j);

/** \brief in 3D honeycombs, returns a vector<bool> v, where v[j] iff faces i and j are adjacent */

const vector<char>& dirdist(cellwalker cw) { return get_cellshape(cw.at).dirdist[cw.spin]; }

/** \brief the sequence of heptagon movement direction to get from c->master to c->move(i)->master; implemented only for reg3 */

virtual const vector<int>& get_move_seq(cell *c, int i);

/** generate a new map that is disconnected from what we already have, disconnected from the map we have so far */

virtual cell* gen_extra_origin(int fv) { throw hr_exception("gen_extra_origin not supported on this map"); }

transmatrix adjmod(cell *c, int i) { return adj(c, gmod(i, c->type)); }

transmatrix adjmod(heptagon *h, int i) { return adj(h, gmod(i, h->type)); }

transmatrix iadjmod(cell *c, int i) { return iadj(c, gmod(i, c->type)); }

transmatrix iadjmod(heptagon *h, int i) { return iadj(h, gmod(i, h->type)); }

/** this takes a large closed manifold M that is a quotient of this, and returns a unique identifier of the cell corresponding to M

virtual int pattern_value(cell *c) { return PATTERN_INVALID; }

virtual struct backed_map* get_backmap() { return nullptr; }

void draw_at(cell *at, const shiftmatrix& where) override;

transmatrix relative_matrixh(heptagon *h2, heptagon *h1, const hyperpoint& hint) override;

transmatrix relative_matrixc(cell *c2, cell *c1, const hyperpoint& hint) override;

heptagon *create_step(heptagon *h, int direction) override;

transmatrix adj(cell *c, int d) override;

transmatrix adj(heptagon *h, int d) override;

ld spin_angle(cell *c, int d) override;

double spacedist(cell *c, int i) override;

void find_cell_connection(cell *c, int d) override;

int shvid(cell *c) override;

hyperpoint get_corner(cell *c, int cid, ld cf) override;

transmatrix master_relative(cell *c, bool get_inverse) override;

bool link_alt(heptagon *h, heptagon *alt, hstate firststate, int dir) override;

void on_dim_change() override;

int pattern_value(cell *c) override;

heptagon *origin;

hrmap_hyperbolic();

hrmap_hyperbolic(heptagon *origin);

heptagon *getOrigin() override { return origin; }

~hrmap_hyperbolic() {

// verifycells(origin);

// printf("Deleting hyperbolic map: %p\n", hr::voidp(this));

clearfrom(origin);

}

void verify() override { verifycells(origin); }

void virtualRebase(heptagon*& base, transmatrix& at) override;

if(&currfp == &fieldpattern::fp_invalid) return 0;

if(NONSTDVAR) return gp::get_pattern_value(c);

if(ctof(c)) return c->master->fieldval/S7;

int z = 0;

for(int u=0; u<S6; u+=2)

z = max(z, fieldpattern::btspin(createMov(c, u)->master->fieldval, c->c.spin(u)));

return -1-z;

if(WDIM == 2) {

return to_other_side(get_corner(c, i), get_corner(c, (i+1)));

}

return currentmap->iadj(c, i);

ld sa = spin_angle(c, d);

if(sa != SPIN_NOT_AVAILABLE) { return spin(bonus + sa); }

transmatrix T = lrspintox(tC0(adj(c, d)));

if(WDIM == 3) return T * cspin(2, 0, bonus);

return T * spin(bonus);

ld sa = spin_angle(c, d);

if(sa != SPIN_NOT_AVAILABLE) { return spin(bonus - sa); }

transmatrix T = lspintox(tC0(adj(c, d)));

if(WDIM == 3) return T * cspin(2, 0, bonus);

return T * spin(bonus);

dd %= t;

if(dd<0) dd += t;

if(t-dd < dd) dd = t-dd;

return dd;

while(c->contents) c->contents->unlist_and_unref();

tailored_delete(c);

cellcount--;

heptagon *h2 = createStep(c->master, d);

c->c.connect(d, h2->c7,c->master->c.spin(d), c->master->c.mirror(d));

hybrid::link();

#if CAP_IRR

if(IRREGULAR) {

irr::link_cell(c, d);

}

#else

if(0) {}

#endif

#if CAP_GP

else if(GOLDBERG) {

gp::extend_map(c, d);

if(!c->move(d)) {

println(hlog, "extend failed to create for ", cellwalker(c, d));

exit(1);

}

hybrid::link();

}

#endif

else if(PURE) {

hrmap::find_cell_connection(c, d);

}

else if(c == c->master->c7) {

cell *n = newCell(S6, c->master);

heptspin hs(c->master, d, false);

int alt3 = c->type/2;

int alt4 = alt3+1;

for(int u=0; u<S6; u+=2) {

if(hs.mirrored && (S7%2 == 0)) hs++;

hs.at->c7->c.connect(hs.spin, n, u, hs.mirrored);

if(hs.mirrored && (S7%2 == 0)) hs--;

hs = hs + alt3 + wstep - alt4;

}

hybrid::link();

extern void verifycell(cell *c);

verifycell(n);

}

else {

cellwalker cw(c, d, false);

cellwalker cw2 = cw - 1 + wstep - 1 + wstep - 1;

c->c.connect(d, cw2);

hybrid::link();

if(!c2) return;

c1->move(s1) = c2; c1->c.setspin(s1, s2, mirror);

c2->move(s2) = c1; c2->c.setspin(s2, s1, mirror);

disksize = req_disksize;

all_disk_cells.clear();

all_disk_cells_sorted.clear();

if(!disksize) return;

if(diskshape == dshTiles) {

celllister cl(currentmap->gamestart(), 1000000, disksize, NULL);

all_disk_cells = cl.lst;

}

else {

struct tileinfo {

ld dist;

cell *c;

transmatrix T;

bool operator < (const tileinfo& t2) const { return -dist < -t2.dist - 1e-6; }

};

set<cell*> seen;

std::priority_queue<tileinfo> tiles;

tiles.push(tileinfo{0, currentmap->gamestart(), Id});

ld last_dist = 0;

dynamicval<int> dmar(mine_adjacency_rule, 1);

while(isize(tiles)) {

auto ti = tiles.top();

tiles.pop();

// println(hlog, "dist=", ti.dist, " for c=", ti.c, " T = ", kz(ti.T), " vs ", ok);

if(seen.count(ti.c)) continue;

seen.insert(ti.c);

if(ti.dist > last_dist + 1e-6 && isize(all_disk_cells) >= disksize) break;

last_dist = ti.dist;

all_disk_cells.push_back(ti.c);

for(auto p: adj_minefield_cells_full(ti.c)) {

tileinfo next;

next.c = p.c;

next.T = ti.T * p.T;

if(diskshape == dshVertices) next.dist = ti.dist + 1;

else next.dist = hdist0(tC0(next.T));

// println(hlog, ti.c, " -> ", p.c, " at ", next.dist, " got T= ", kz(p.T));

tiles.push(next);

}

}

}

all_disk_cells_sorted = all_disk_cells;

sort(all_disk_cells_sorted.begin(), all_disk_cells_sorted.end());

auto it = lower_bound(all_disk_cells_sorted.begin(), all_disk_cells_sorted.end(), c);

if(it == all_disk_cells_sorted.end()) return false;

return *it == c;

auto it = lower_bound(all_disk_cells_sorted.begin(), all_disk_cells_sorted.end(), c);

if(it == all_disk_cells_sorted.end() || *it != c) return isize(all_disk_cells_sorted);

return it - all_disk_cells_sorted.begin();

int x = g.first;

int y = g.second;

set<pair<int, int>> visited;

while(true) {

if(visited.count({x,y})) return false;

visited.insert({x,y});

// if(x == -1 && y == -2) return false;

// if(x == -2 && y == -3) return false;

if(x == 0 && y == 0) return true;

if((x&1) == 1 && (y&1) == 1) return false;

x >>= 1;

y >>= 1;

// x--; y++;

tie(x, y) = make_pair(-x-y, x);

}

int x = g.first;

int y = g.second;

set<pair<int, int>> visited;

if(S7 == 6)

x += 2785684, y += 289080;

else

x += 75239892, y += 7913772;

while(true) {

if(visited.count({x,y})) return false;

visited.insert({x,y});

if(x == 0 && y == 0) return true;

int dx = gmod(x, 3);

int dy = gmod(y, 3);

if(dx == 1 && dy == 1) return false;

if(S7 == 6 && dx == dy) return false;

x = (x-dx) / 3;

y = (y-dy) / 3;

}

c[0] += 528120*9; c[1] += 438924*9; c[2] += 306712*9;

set<euc::coord> visited;

while(true) {

if(visited.count(c)) return false;

visited.insert(c);

if(c[0] == 0 && c[1] == 0 && c[2] == 0) return true;

int ones = 0;

for(int i=0; i<3; i++) {

int d = gmod(c[i], 3);

c[i] = (c[i] - d) / 3;

if(d == 1) ones++;

}

if(ones >= 2) return false;

}

set<euc::coord> visited;

c[0] += 16 * (1+8+64+512);

c[1] += 16 * (1+8+64+512);

c[1] += 32 * (1+8+64+512);

c[2] += 32 * (1+8+64+512);

c[0] += 64 * (1+8+64+512);

c[1] += 64 * (1+8+64+512);

while(true) {

if(visited.count(c)) return false;

visited.insert(c);

if(c[0] == 0 && c[1] == 0 && c[2] == 0) return true;

int ones = 0;

for(int i=0; i<3; i++) {

int d = gmod(c[i], 2);

c[i] = (c[i] - d) / 2;

if(d == 1) ones++;

}

if(ones & 1) return false;

}

if(fake::in()) return FPIU(is_in_fractal(c));

if(mhybrid) { c = hybrid::get_where(c).first; return PIU(is_in_fractal(c)); }

switch(geometry) {

case gSierpinski3:

return sierpinski3(euc::full_coords2(c));

case gSierpinski4:

case gSixFlake:

return sierpinski46(euc::full_coords2(c));

case gMengerSponge:

return menger_sponge(euc::get_ispacemap()[c->master]);

case gSierpinskiTet: {

return sierpinski_tet(euc::get_ispacemap()[c->master]);

}

default:

return true;

}

indenter_finish dif(debug_init_cells, "initcells");

if(debug_init_cells) println(hlog, "creating the map for geometry: ", full_geometry_name());

if(embedded_plane) {

geom3::swap_direction = -1;

check_cgi();

for(auto& m: cgi.heptmove) swapmatrix(m);

IPF(initcells());

check_cgi();

geom3::swap_direction = +1;

for(auto& m: cgi.heptmove) swapmatrix(m);

currentmap->reinit();

return;

}

hrmap* res = callhandlers((hrmap*)nullptr, hooks_newmap);

if(res) currentmap = res;

#if CAP_SOLV

else if(asonov::in()) currentmap = asonov::new_map();

#endif

else if(nonisotropic || mhybrid) currentmap = nisot::new_map();

else if(INVERSE) currentmap = gp::new_inverse();

else if(fake::in()) currentmap = fake::new_map();

#if CAP_CRYSTAL

else if(cryst) currentmap = crystal::new_map();

#endif

else if(arb::in() && rulegen::known()) currentmap = rulegen::new_hrmap_rulegen();

else if(arb::in()) currentmap = arb::new_map();

#if CAP_ARCM

else if(arcm::in()) currentmap = arcm::new_map();

#endif

else if(euc::in()) currentmap = euc::new_map();

else if(hat::in()) currentmap = hat::new_map();

#if CAP_BT

else if(kite::in()) currentmap = kite::new_map();

#endif

#if MAXMDIM >= 4

else if(WDIM == 3 && !bt::in()) currentmap = reg3::new_map();

#endif

else if(sphere) currentmap = new_spherical_map();

else if(quotient) currentmap = quotientspace::new_map();

#if CAP_BT

else if(bt::in()) currentmap = bt::new_map();

#endif

else if(S3 >= OINF) currentmap = inforder::new_map();

else currentmap = new hrmap_hyperbolic;

allmaps.push_back(currentmap);

#if CAP_FIELD

windmap::create();

#endif

// origin->emeraldval =

if(!c) return;

indenter_finish iclearcell(debug_memory_cell, hr::format("memory_cell %d %p\n", c->type, hr::voidp(c)));

for(int t=0; t<c->type; t++) if(c->move(t)) {

if(debug_memory_cell)

println(hlog, hr::format("mov %p [%p] S%d\n", hr::voidp(c->move(t)), hr::voidp(c->move(t)->move(c->c.spin(t))), c->c.spin(t)));

if(c->move(t)->move(c->c.spin(t)) != NULL &&

c->move(t)->move(c->c.spin(t)) != c) {

if(debug_errors || debug_memory_cell)

println(hlog, hr::format("cell error: type = %d %d -> %d\n", c->type, t, c->c.spin(t)));

if(worst_precision_error < 1e-3)

throw hr_exception("clearcell");

}

c->move(t)->move(c->c.spin(t)) = NULL;

}

if(debug_memory_cell)

println(hlog, hr::format("DEL %p\n", hr::voidp(c)));

gp::delete_mapped(c);

destroy_cell(c);

if(GOLDBERG) {

forCellEx(c2, c) if(c2->move(0) == c && c2 != c2->master->c7) {

subcell(c2, t);

}

}

else if(BITRUNCATED && !arcm::in() && !bt::in())

forCellEx(c2, c) t(c2);

t(c);

if(at->c7 && at->cdata) {

delete at->cdata;

at->cdata = NULL;

}

if(0);

#if CAP_IRR

else if(IRREGULAR) irr::clear_links(at);

#endif

else if(at->c7) subcell(at->c7, clearcell);

if(h->alt && h->c7) {

if(h->alt->cdata == (cdata*) h)

h->alt->cdata = NULL;

}

if(!at) return;

queue<heptagon*> q;

unlink_cdata(at);

q.push(at);

at->alt = &deletion_marker;

while(!q.empty()) {

at = q.front();

q.pop();

if(debug_memory_cell) println(hlog, "from %p", at);

if(!at->c7 && !ls::voronoi_structure()) {

heptagon *h = dynamic_cast<heptagon*> ((cdata_or_heptagon*) at->cdata);

if(h) {

if(h->alt != at && (debug_memory_cell || debug_errors))

println(hlog, "alt error :: h->alt = ", h->alt, " expected ", at);

cell *c = h->c7;

subcell(c, destroycellcontents);

h->alt = NULL;

at->cdata = NULL;

}

}

int edges = at->degree();

if(bt::in() && WDIM == 2) edges = at->c7->type;

for(int i=0; i<edges; i++) if(at->move(i) && at->move(i) != at) {

if(at->move(i)->alt != &deletion_marker)

q.push(at->move(i));

unlink_cdata(at->move(i));

at->move(i)->alt = &deletion_marker;

if(debug_memory_cell) println(hlog, "!mov ", at->move(i), " [", at->move(i)->move(at->c.spin(i)), "]");

if(at->move(i)->move(at->c.spin(i)) != NULL &&

at->move(i)->move(at->c.spin(i)) != at)

throw hr_exception("hept error");

at->move(i)->move(at->c.spin(i)) = NULL;

at->move(i) = NULL;

}

clearHexes(at);

tailored_delete(at);

}

int t = c->type;

for(int i=0; i<t; i++) {

cell *c2 = c->move(i);

if(c2) {

if(BITRUNCATED && c == c->master->c7) verifycell(c2);

if(c2->move(c->c.spin(i)) && c2->move(c->c.spin(i)) != c) {

printf("cell error %p:%d [%d] %p:%d [%d]\n", hr::voidp(c), i, c->type, hr::voidp(c2), c->c.spin(i), c2->type);

throw hr_exception("error during verifycell");

}

}

}

if(GOLDBERG || IRREGULAR || arcm::in()) return;

for(int i=0; i<at->type; i++) if(at->move(i) && at->move(i)->move(at->c.spin(i)) && at->move(i)->move(at->c.spin(i)) != at) {

printf("hexmix error %p [%d s=%d] %p %p\n", hr::voidp(at), i, at->c.spin(i), hr::voidp(at->move(i)), hr::voidp(at->move(i)->move(at->c.spin(i))));

}

if(!sphere && !quotient)

for(int i=0; i<S7; i++) if(at->move(i) && at->c.spin(i) == 0 && at->s != hsOrigin)

verifycells(at->move(i));

verifycell(at->c7);

int mi = dx[0];

for(int u=0; u<S3; u++) mi = min(mi, dx[u]);

for(int u=0; u<S3; u++)

if(dx[u] > mi+2)

return -1; // { printf("cycle error!\n"); exit(1); }

for(int u=0; u<S3; u++)

if(dx[u] == mi+2)

return mi+1;

int cnt = 0;

for(int u=0; u<S3; u++)

if(dx[u] == mi) cnt++;

if(cnt < 2)

return mi+1;

return mi;

if(experimental) return 0;

if(mhybrid)

return hybrid::celldistance(c, currentmap->gamestart());

if(nil && !quotient) return DISTANCE_UNKNOWN;

if(hat::in()) return clueless_celldistance(currentmap->gamestart(), c);

if(euc::in()) return celldistance(currentmap->gamestart(), c);

if(sphere || bt::in() || WDIM == 3 || cryst || sn::in() || aperiodic || closed_manifold) return celldistance(currentmap->gamestart(), c);

#if CAP_IRR

if(IRREGULAR) return irr::celldist(c, false);

#endif

if(arcm::in() || ctof(c) || arb::in()) return c->master->distance;

#if CAP_GP

if(INVERSE) {

cell *c1 = gp::get_mapped(c);

return UIU(gp::compute_dist(c1, celldist)) / 2;

/* TODO */

}

if(GOLDBERG) return gp::compute_dist(c, celldist);

#endif

int dx[MAX_S3];

for(int u=0; u<S3; u++)

dx[u] = createMov(c, u+u)->master->distance;

return compdist(dx);

if(experimental) return 0;

if(mhybrid) {

if(in_s2xe()) return hybrid::get_where(c).second;

auto w = hybrid::get_where(c);

int d = c->master->alt && c->master->alt->alt ? hybrid::altmap_heights[c->master->alt->alt] : 0;

d = sl2 ? 0 : abs(w.second - d);

PIU ( d += celldistAlt(w.first) );

return d;

}

#if CAP_BT

if(bt::in() || sn::in()) return c->master->distance + (specialland == laCamelot && !ls::single() ? 30 : 0);

#endif

if(nil) return c->master->zebraval + abs(c->master->emeraldval) + (specialland == laCamelot && !ls::single() ? 30 : 0);;

#if CAP_CRYSTAL

if(cryst)

return crystal::dist_alt(c);

#endif

if(sphere || quotient) {

return celldist(c) - 3;

}

#if MAXMDIM >= 4

if(euc::in()) return euc::dist_alt(c);

if(hyperbolic && WDIM == 3 && !reg3::in_hrmap_rule_or_subrule())

return reg3::altdist(c->master);

#endif

if(!c->master->alt) return 0;

#if CAP_IRR

if(IRREGULAR) return irr::celldist(c, true);

#endif

if(ctof(c)) return c->master->alt->distance;

if(reg3::in()) return c->master->alt->distance;

#if CAP_GP

if(GOLDBERG) return gp::compute_dist(c, celldistAlt);

if(INVERSE) {

cell *c1 = gp::get_mapped(c);

return UIU(gp::compute_dist(c1, celldistAlt)) / 2;

/* TODO */

}

#endif

int dx[MAX_S3]; dx[0] = 0;

for(int u=0; u<S3; u++) if(createMov(c, u+u)->master->alt == NULL)

return ALTDIST_UNKNOWN;

for(int u=0; u<S3; u++)

dx[u] = createMov(c, u+u)->master->alt->distance;

// return compdist(dx); -> not OK because of boundary conditions

int mi = dx[0];

for(int i=1; i<S3; i++) mi = min(mi, dx[i]);

for(int i=0; i<S3; i++) if(dx[i] > mi+2)

return ALTDIST_BOUNDARY; // { printf("cycle error!\n"); exit(1); }

for(int i=0; i<S3; i++) if(dx[i] == mi+2)

return mi+1;

return mi;

#if CAP_BT

if(bt::in()) return bt::updir();

#endif

#if MAXMDIM >= 4

if(WDIM == 3 && reg3::in_hrmap_rule_or_subrule()) {

for(int i=0; i<h->type; i++) if(h->move(i) && h->move(i)->distance < h->distance)

return i;

return -1;

}

#endif

if(h->s == hsOrigin) return -1;

return 0;

if(euclid || !h->alt) return -1;

#if MAXMDIM >= 4

if(WDIM == 3 && reg3::in_hrmap_rule_or_subrule()) {

for(int i=0; i<S7; i++) if(h->move(i) && h->move(i)->alt && h->move(i)->alt->distance < h->alt->distance)

return i;

return -1;

}

#endif

return gmod(updir(h->alt) + altmap::relspin(h->alt), h->type);

int i, sw=0;

switch(rval%5) {

case 0:

if(rval&1) {

return hrandpos() < rval;

}

else {

int cd = getCdata(c, 0);

return !((cd/(((rval/2)&15)+1))&1);

}

case 1:

i = zebra40(c);

if(i&1) { if(rval&4) sw^=1; i &= ~1; }

if(i&2) { if(rval&8) sw^=1; i &= ~2; }

i >>= 2;

i--; i /= 3;

if(rval & (16<<i)) sw^=1;

return sw;

case 2:

i = emeraldval(c);

if(i&1) { if(rval&4) sw^=1; i &= ~1; }

if(i&2) { if(rval&8) sw^=1; i &= ~2; }

i >>= 2; i--;

if(rval & (16<<i)) sw^=1;

return sw;

case 3:

if(polara50(c)) { if(rval&4) sw^=1; }

if(polarb50(c)) { if(rval&8) sw^=1; }

i = fiftyval049(c); i += 6; i /= 7;

if(rval & (16<<i)) sw^=1;

return sw;

case 4:

i = (rval&3);

if(i == 1 && (celldist(c)&1)) sw ^= 1;

if(i == 2 && (celldist(c)&2)) sw ^= 1;

if(i == 3 && ((celldist(c)/3)&1)) sw ^= 1;

if(rval & (4<<towerval(c, celldist))) sw ^= 1;

return sw;

}

return 0;

int rval = randompattern[l];

switch(rval%5) {

case 0:

if(rval&1)

return "R:"+its(rval/(HRANDMAX/100))+"%";

else

return "Landscape/"+its(((rval/2)&15)+1);

case 1:

return "Z/"+its((rval>>2)&3)+"/"+its((rval>>4)&15);

case 2:

return "E/"+its((rval>>2)&3)+"/"+its((rval>>4)&2047);

case 3:

return "P/"+its((rval>>2)&3)+"/"+its((rval>>4)&255);

case 4:

return "C/"+its(rval&3)+"/"+its((rval>>2)&65535);

}

return "?";

switch(rval % RPV_MODULO) {

case 1:

return zebra40(c);

case 2:

return emeraldval(c);

case 3:

return fiftyval049(c) + (polara50(c)?50:0) + (polarb50(c)?1000:0);

case 4:

return towerval(c, celldist) * 6 + celldist(c) % 6;

}

return 0;