diff options
Diffstat (limited to 'life2x/life2x.c')
| -rw-r--r-- | life2x/life2x.c | 675 |
1 files changed, 675 insertions, 0 deletions
diff --git a/life2x/life2x.c b/life2x/life2x.c new file mode 100644 index 0000000..fda90b8 --- /dev/null +++ b/life2x/life2x.c @@ -0,0 +1,675 @@ +/* Life2x.c -- The Game of Life (2D Cellular Automaton) ------- */ +/* © Bill Vorn 2002 */ +/* modified by Martin Peach September 2002 */ +/* implemented grey scale display*/ +/* change gen_ arrays to pointers for better memory peformance */ +/* <<better memory!>> */ +/* MP20060517 Windows version */ +/* MP 20080819 pd version with no graphics */ + +#include "m_pd.h" +#include <stdio.h> /* for sprintf() */ +#include <stdlib.h> /* for random() */ +#include <time.h> /* for clock() */ + +#define MAXSIZE 1024 +#define DEFAULT_DIM 16 + +static t_class *life2x_class; + +typedef struct life2x +{ + t_object x_obj; + char *gen_origin_ptr; /* [MAXSIZE]X[MAXSIZE]; */ + char *gen_finale_ptr; /* [MAXSIZE][MAXSIZE]; */ + char *gen_start_ptr; /* [MAXSIZE][MAXSIZE]; */ + char *gen_shift_ptr; /* [MAXSIZE][MAXSIZE]; */ + t_atom *l_column_list; /* values for one column */ + long l_cellmax; /* number of bytes in gen */ + long l_xcellnum; + long l_ycellnum; + long l_gennum; + long l_livenum; + long l_deltanum; + long l_lastdeltanum; + long l_novarinum; + long l_novar; + short l_deadflag; + short l_thruflag; + short l_xshift; + short l_yshift; + short l_invertflag; + t_outlet *l_genout; + t_outlet *l_liveout; + t_outlet *l_deltaout; + t_outlet **l_cellouts; + t_outlet *l_novariout; + t_outlet *l_deadout; + t_outlet *l_dumpout; + char l_survive[9]; /* rule for survival according to neighbour count */ + char l_born[9]; /* rule for birth according to neighbour count */ +} t_life2x; + +static void life2x_bang(t_life2x *x); +static void life2x_output_cells(t_life2x *x); +static void life2x_set(t_life2x *x, t_floatarg xx, t_floatarg yy, t_floatarg state); +static void life2x_clear(t_life2x *x); +static void life2x_reset(t_life2x *x); +static void life2x_return(t_life2x *x); +static void life2x_dump(t_life2x *x); +static void life2x_rule(t_life2x *x, t_symbol *s); +static void life2x_randomize(t_life2x *x, t_floatarg f); +static void life2x_thru(t_life2x *x, t_floatarg f); +static void life2x_shift(t_life2x *x, t_floatarg f1, t_floatarg f2); +static void life2x_flipv(t_life2x *x); +static void life2x_fliph(t_life2x *x); +static void life2x_invert(t_life2x *x, t_floatarg f); +static void life2x_novar(t_life2x *x, t_floatarg f); +static void life2x_free(t_life2x *x); +static void *life2x_new(t_symbol *s, short ac, t_atom *av); + +void life2x_setup(void) +{ + life2x_class = class_new(gensym("life2x"), + (t_newmethod)life2x_new, + (t_method)life2x_free, + sizeof(t_life2x), + CLASS_DEFAULT, + A_GIMME, + 0); + class_addbang(life2x_class, life2x_bang); + class_addmethod(life2x_class, (t_method)life2x_clear, gensym("clear"), 0); + class_addmethod(life2x_class, (t_method)life2x_reset, gensym("reset"), 0); + class_addmethod(life2x_class, (t_method)life2x_return, gensym("return"), 0); + class_addmethod(life2x_class, (t_method)life2x_dump, gensym("dump"), 0); + class_addmethod(life2x_class, (t_method)life2x_rule, gensym("rule") ,A_DEFSYMBOL, 0); + class_addmethod(life2x_class, (t_method)life2x_randomize, gensym("randomize"), A_DEFFLOAT, 0); + class_addmethod(life2x_class, (t_method)life2x_thru, gensym("thru") ,A_DEFFLOAT, 0); + class_addmethod(life2x_class, (t_method)life2x_shift, gensym("shift"), A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(life2x_class, (t_method)life2x_set, gensym("set"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + class_addmethod(life2x_class, (t_method)life2x_flipv, gensym("flipv"), 0); + class_addmethod(life2x_class, (t_method)life2x_fliph, gensym("fliph"), 0); + class_addmethod(life2x_class, (t_method)life2x_invert, gensym("invert"), A_DEFFLOAT, 0); + class_addmethod(life2x_class, (t_method)life2x_novar, gensym("novar"), A_DEFFLOAT, 0); + return; +} + +static void life2x_bang(t_life2x *x) +{ + short i, j, m, n, p, q; + short i_pre, i_post, j_pre, j_post; + short xmax, ymax; + unsigned long cellmax; + short xshft, yshft; + char c; + short cellval; + long gendiff, lastgendiff; + char *g_start, *g_origin, *g_final, *g_shift; + int c_live; + + xmax = x->l_xcellnum - 1; + ymax = x->l_ycellnum - 1; + cellmax = x->l_xcellnum * x->l_ycellnum; + xshft = x->l_xshift; + yshft = x->l_yshift; + + if (x->l_gennum == 0) + { + g_start = x->gen_start_ptr; + g_origin = x->gen_origin_ptr; + for (j = 0; j < cellmax; ++j) *g_start++ = *g_origin++; + } + + for (j = 0; j <= ymax; j++) + { + j_pre = j-1; + if (j_pre < 0) j_pre = ymax; + j_post = j+1; + if (j_post > ymax) j_post = 0; + for (i = 0; i <= xmax; i++) + { + i_pre = i-1; + if (i_pre < 0) i_pre = xmax; + i_post = i+1; + if (i_post > xmax) i_post = 0; + /* check each neighbour */ + cellval = (*(x->gen_origin_ptr+(j_pre*x->l_xcellnum)+(i_pre)) != 0) + +(*(x->gen_origin_ptr+(j_pre*x->l_xcellnum)+i) != 0) + +(*(x->gen_origin_ptr+(j_pre*x->l_xcellnum)+i_post) != 0) + +(*(x->gen_origin_ptr+(j*x->l_xcellnum)+i_pre) != 0) + +(*(x->gen_origin_ptr+(j*x->l_xcellnum)+i_post) != 0) + +(*(x->gen_origin_ptr+(j_post*x->l_xcellnum)+i_pre) != 0) + +(*(x->gen_origin_ptr+(j_post*x->l_xcellnum)+i) != 0) + +(*(x->gen_origin_ptr+(j_post*x->l_xcellnum)+i_post) != 0); + + c = *(x->gen_origin_ptr+(j*x->l_xcellnum)+i); /* current value of cell */ + g_final = (x->gen_finale_ptr+(j*x->l_xcellnum)+i); + + /* apply the rule */ + if (c == 0) c_live = x->l_born[cellval]; /* cell is born if it has the right number of neighbours */ + else c_live = x->l_survive[cellval]; /* cell survives if it has the right number of neighbours */ + + if (c_live == 1) + { + if (c < 8) *g_final = c + 1; + else *g_final = 8; + } + else *g_final = 0; + } + } + + if ((xshft != 0) || (yshft != 0)) + { /* if there is a shift offset */ + for (j = 0; j <= ymax; j++) + { + n = j + yshft; + if (n < 0) q = (n + ymax) + 1; + else if (n > ymax) q = (n - ymax) - 1; + else q = n; + for (i = 0; i <= xmax; i++) + { + m = i + xshft; + if (m < 0) p = (m + xmax) + 1; + else if (m > xmax) p = (m - xmax) - 1; + else p = m; + *(x->gen_shift_ptr+(q * x->l_xcellnum)+p) = *(x->gen_finale_ptr+(j * x->l_xcellnum)+i); + } + } + g_final = x->gen_finale_ptr; + g_shift = x->gen_shift_ptr; + + for (j = 0; j <= cellmax; j++) *g_final++ = *g_shift++; + } + + x->l_gennum = x->l_gennum + 1; /* increment generation # */ + outlet_float(x->l_genout, x->l_gennum); /* output generation # */ + + life2x_output_cells(x); + + gendiff = x->l_livenum - x->l_deltanum; /* compare # of live cells from last gen to current gen */ + outlet_float(x->l_deltaout, gendiff); /* output delta # of live cells from last gen to current gen */ + x->l_deltanum = x->l_livenum; /* store # of live cells from current gen */ + + outlet_float(x->l_liveout, x->l_livenum); /* output # of live cells in current generation */ + + lastgendiff = x->l_lastdeltanum; + if (gendiff == lastgendiff) x->l_novar--; + else x->l_novar = x->l_novarinum; /* reset countdown */ + if (x->l_novar == 0) + { + outlet_bang(x->l_novariout); + x->l_novar = x->l_novarinum; + } + x->l_lastdeltanum = gendiff; + + x->l_deadflag = 0; + for (j = 0; j < x->l_ycellnum; j++) + { + for (i = 0; i < x->l_xcellnum; i++) + { + g_final = (x->gen_finale_ptr+(j*x->l_xcellnum)+i); + g_origin = (x->gen_origin_ptr+(j*x->l_xcellnum)+i); + /* check for gen difference: */ + if (*g_final != *g_origin) x->l_deadflag = 1; + *g_origin = *g_final; /* this generation becomes last generation */ + } + } + /* check for dead world: */ + if (x->l_deadflag == 0) outlet_bang(x->l_deadout); + + return; +} + +static void life2x_output_cells(t_life2x *x) +{ + char *g_final; + short i, j; + long d = 0; + + for (i = 0; i < x->l_xcellnum; i++) + { /* output all cells state for each column */ + for (j = 0; j < x->l_ycellnum; j++) + { + g_final = (x->gen_finale_ptr+(j*x->l_xcellnum)+i); + if (x->l_invertflag != 0) x->l_column_list[j].a_w.w_float = (10 - *g_final)%9; + else x->l_column_list[j].a_w.w_float = *g_final; + if (*g_final != 0) d++; + } + outlet_list(x->l_cellouts[x->l_xcellnum-1-i], &s_list, j, x->l_column_list); + } + x->l_livenum = d; + + return; +} + +static void life2x_set(t_life2x *x, t_floatarg xx, t_floatarg yy, t_floatarg state) +{ /* a list of three floats to set the state of cell (xx,yy) */ + short i, j, k; + + if (xx < 0) i = 0; + if (xx >= x->l_xcellnum) i = x->l_xcellnum - 1; + else i = (short)xx; + if (yy < 0) j = 0; + if (yy > x->l_ycellnum) j = x->l_ycellnum - 1; + else j = (short)yy; + + if (state < 0) k = 0; + if (state > 8) k = 8; + else k = (short)state; + + *(x->gen_origin_ptr+(j*x->l_xcellnum+i)) = k; + *(x->gen_finale_ptr+(j*x->l_xcellnum+i)) = k; + + if (x->l_thruflag != 0) life2x_output_cells(x); + return; +} + +static void life2x_clear(t_life2x *x) +{ + short j; + char *g_origin, * g_final; + + g_origin = x->gen_origin_ptr; + g_final = x->gen_finale_ptr; + + for (j = 0; j < x->l_cellmax; ++j) *g_origin++ = *g_final++ = 0; + + if (x->l_thruflag != 0) life2x_output_cells(x); + + return; +} + +static void life2x_reset(t_life2x *x) +{ + short j; + char *g_origin, * g_final; + + g_origin = x->gen_origin_ptr; + g_final = x->gen_finale_ptr; + x->l_gennum = 0; + + outlet_float (x->l_genout, x->l_gennum); /* output generation 0 */ + + for (j = 0; j < x->l_cellmax; ++j) *g_origin++ = *g_final++ = 0; + + x->l_xshift = 0; + x->l_yshift = 0; + x->l_deltanum = 0; + x->l_novar = x->l_novarinum; + + if (x->l_thruflag != 0) life2x_output_cells(x); + + return; +} + +static void life2x_return(t_life2x *x) +{ + short i, j; + char *g_origin, *g_start, *g_final; + + x->l_gennum = 0; + outlet_float (x->l_genout, x->l_gennum); /* output generation 0 */ + + for (j = 0; j < x->l_ycellnum; j++) + { + for (i = 0; i < x->l_xcellnum; i++) + { + g_origin = (x->gen_origin_ptr+(j*x->l_xcellnum)+i); + g_start = (x->gen_start_ptr+(j*x->l_xcellnum)+i); + g_final = (x->gen_finale_ptr+(j*x->l_xcellnum)+i); + + *g_origin = *g_start; + *g_final = *g_start; + } + } + if (x->l_thruflag != 0) life2x_output_cells(x); + return; +} + +static void life2x_dump(t_life2x *x) +{ + short i, j, k; + unsigned long count = 0; + unsigned long outVal[3]; + t_atom outList[3]; + char *g_final = x->gen_finale_ptr; + + for (j = 0; j < x->l_ycellnum; ++j) + { + for (i = 0; i < x->l_xcellnum; ++i) + { + if (*g_final++) + { + outVal[0] = count; + outVal[1] = i; + outVal[2] = j; + for (k = 0; k < 3; k++) SETFLOAT(&outList[k], outVal[k]); + outlet_list (x->l_dumpout, &s_list, 3, outList); + count++; + } + } + } + return; +} + +static void life2x_rule(t_life2x *x, t_symbol *s) +{ + short i; + char survive[9]; +/* one entry for each possible neighbour count, set to one if cell survives with that many neighbours */ + char born[9]; +/* one entry for each possible neighbour count, set to one if cell is born with that many neighbours */ + + for (i = 0; i < 9; ++i) survive[i] = born[i] = 0; + + for (i = 0; s->s_name[i] != 0; ++i) + { + if (s->s_name[i] == '/') break; + if ((s->s_name[i] < 0x30)||(s->s_name[i] > 0x38)) + { + error("life2x_rule: bad character in rule: %c", s->s_name[i]); + return; + } + survive[s->s_name[i]-0x30] = 1; + } + if (s->s_name[i] != '/') + { + error("life2x_rule: missing / separator"); + return; + } + for (++i; s->s_name[i] != 0; ++i) + { + if ((s->s_name[i] < 0x30)||(s->s_name[i] > 0x38)) + { + error("life2x_rule: bad character in rule: %c", s->s_name[i]); + return; + } + born[s->s_name[i]-0x30] = 1; + } + for (i = 0; i < 9; ++i) + { /* update the rule */ + x->l_survive[i] = survive[i]; + x->l_born[i] = born[i]; + } + return; +} + +static void life2x_randomize(t_life2x *x, t_floatarg f) +{ /* set a random fraction of the array alive */ + short i, j; + float threshold; + + if (f > 1.0) f = 1.0; + else if (f < 0.0) f = 0.0; + threshold = RAND_MAX*f; /* RAND_MAX is 0x7FFFFFFF on linux */ + + for (j = 0; j < x->l_ycellnum; j++) + { + for (i = 0; i < x->l_xcellnum; i++) + { + if ((random() < threshold)) + { + *(x->gen_origin_ptr+(j*x->l_xcellnum)+i) = 1; + *(x->gen_finale_ptr+(j*x->l_xcellnum)+i) = 1; + } + } + } + if (x->l_thruflag != 0) life2x_output_cells(x); + return; +} + +static void life2x_thru(t_life2x *x, t_floatarg f) +{ + long n = (long)f; + + x->l_thruflag = (n == 0)? 0: 1; + return; +} + +static void life2x_shift(t_life2x *x, t_floatarg f1, t_floatarg f2) +{ + long n = (long)f1; + + n %= x->l_xcellnum; + x->l_xshift = n; + n = (long)f2; + n %= x->l_ycellnum; + x->l_yshift = n; + return; +} + +static void life2x_flipv(t_life2x *x) +{ + short a, i, j; + + for (i = 0; i < x->l_xcellnum; ++i) + { + a = x->l_xcellnum - 1; + for (j = 0; j < x->l_xcellnum; ++j) + { + *(x->gen_shift_ptr+(a*x->l_xcellnum)+i) = *(x->gen_finale_ptr+(j*x->l_xcellnum)+i); + a--; + } + } + for (j = 0; j < x->l_ycellnum; ++j) + { + for (i = 0; i < x->l_xcellnum; ++i) + { + *(x->gen_finale_ptr+(j*x->l_xcellnum)+i) = *(x->gen_shift_ptr+(j*x->l_xcellnum)+i); + *(x->gen_origin_ptr+(j*x->l_xcellnum)+i) = *(x->gen_shift_ptr+(j*x->l_xcellnum)+i); + } + } + + if (x->l_thruflag != 0) life2x_output_cells(x); + + return; +} + +static void life2x_fliph(t_life2x *x) +{ + short a, i, j; + + for (j = 0; j < x->l_ycellnum - 1; ++j) + { + a = x->l_xcellnum - 1; + for (i = 0; i < x->l_xcellnum; ++i) + { + *(x->gen_shift_ptr+(j*x->l_xcellnum)+a) = *(x->gen_finale_ptr+(j*x->l_xcellnum)+i); + a--; + } + } + for (j = 0; j < x->l_ycellnum - 1; ++j) + { + for (i = 0; i < x->l_xcellnum - 1; ++i) + { + *(x->gen_finale_ptr+(j*x->l_xcellnum)+i) = *(x->gen_shift_ptr+(j*x->l_xcellnum)+i); + *(x->gen_origin_ptr+(j*x->l_xcellnum)+i) = *(x->gen_shift_ptr+(j*x->l_xcellnum)+i); + } + } + + if (x->l_thruflag != 0) life2x_output_cells(x); + + return; +} + +static void life2x_invert(t_life2x *x, t_floatarg f) +{ + x->l_invertflag = (f == 0)? 0: 1; + + if (x->l_thruflag != 0) life2x_output_cells(x); + + return; +} + +static void life2x_novar(t_life2x *x, t_floatarg f) +{ + long n = (long)f; + + if (n < 0) + { + error("life2x: novar argument must be positive"); + return; + } + else + { + x->l_novarinum = n; + x->l_novar = n; + } + return; +} + + +static void life2x_free(t_life2x *x) +{ + if (x->gen_origin_ptr != NULL) freebytes (x->gen_origin_ptr, x->l_cellmax); + if (x->gen_finale_ptr != NULL) freebytes (x->gen_finale_ptr, x->l_cellmax); + if (x->gen_start_ptr != NULL) freebytes (x->gen_start_ptr, x->l_cellmax); + if (x->gen_shift_ptr != NULL) freebytes (x->gen_shift_ptr, x->l_cellmax); + if (x->l_column_list != NULL) freebytes(x->l_column_list, x->l_ycellnum*sizeof (t_atom)); + if (x->l_cellouts != NULL) freebytes(x->l_cellouts, x->l_xcellnum*sizeof (t_outlet*)); + return; +} + + +static void *life2x_new(t_symbol *s, short ac, t_atom *av) +{ + t_life2x *x; + short i; + short j; + short xmax, ymax; + + x = (t_life2x *)pd_new(life2x_class); + + if (ac > 0) + { /* if there is at least 1 argument */ + if (av[0].a_type == A_FLOAT) + { /* if first arg is an int */ + x->l_xcellnum = av[0].a_w.w_float; /* arg sets # of horiz cells */ + if (x->l_xcellnum < 4) + { + error("Life: first argument < 4, set to 4"); + x->l_xcellnum = 4; /* min # of horiz cells */ + } + if (x->l_xcellnum > MAXSIZE) + { + error("Life: first argument > %d, set to %d", MAXSIZE, MAXSIZE); + x->l_xcellnum = MAXSIZE; /* max # of horiz cells */ + } + /* if 2 arguments */ + if ((ac > 1) && (av[1].a_type == A_FLOAT)) + { /* if 2nd arg is an int */ + x->l_ycellnum = av[1].a_w.w_float; /* 2nd arg sets # of verti cells */ + if (x->l_ycellnum < 4) + { + error("Life: 2nd argument < 4, set to 4"); + x->l_ycellnum = 4; /* min # of verti cells */ + } + if (x->l_ycellnum > MAXSIZE) + { + error("Life: 2nd argument > %d, set to %d", MAXSIZE, MAXSIZE); + x->l_ycellnum = MAXSIZE; /* max # of verti cells */ + } + } + else if (ac > 1) + { /* if 2nd arg not an int */ + error("Life: 2nd argument must be int"); + x->l_ycellnum = DEFAULT_DIM; /* default # of verti cells */ + } + else + { /* if no 2nd arg */ + x->l_ycellnum = x->l_xcellnum; /* # of verti cells = # of horiz cells */ + } + } + else + { /*if first arg not an int */ + error("Life: first argument must be int"); + x->l_xcellnum = DEFAULT_DIM; /* default # of horiz cells */ + x->l_ycellnum = DEFAULT_DIM; /* default # of verti cells */ + } + } + else + { /* if no arg */ + x->l_xcellnum = DEFAULT_DIM; /* default # of horiz cells */ + x->l_ycellnum = DEFAULT_DIM; /* default # of verti cells */ + } + + x->l_cellmax = x->l_xcellnum*x->l_ycellnum; + if ((x->gen_origin_ptr = getbytes(x->l_cellmax)) != NULL) + if ((x->gen_finale_ptr = getbytes(x->l_cellmax)) != NULL) + if ((x->gen_start_ptr = getbytes(x->l_cellmax)) != NULL) + x->gen_shift_ptr = getbytes(x->l_cellmax); + if + ( + (x->gen_origin_ptr == NULL) + || (x->gen_finale_ptr == NULL) + || (x->gen_start_ptr == NULL) + || (x->gen_shift_ptr == NULL) + ) + { + error ("Unable to allocate memory for the life array (%luX%lu needs %lu bytes)", + x->l_xcellnum, x->l_ycellnum, x->l_cellmax*4L); + life2x_free (x); + return x; + } + + x->l_column_list = getbytes(x->l_ycellnum*sizeof (t_atom)); + if (x->l_column_list == NULL) + { + error("life2x_new: Unable to allocate %lu bytes for column list", + x->l_ycellnum*sizeof (t_atom)); + life2x_free (x); + return x; + } + for (j = 0; j < x->l_ycellnum; ++j) SETFLOAT(&x->l_column_list[j], 0); + /* (we can go faster later by making the atoms floats now) */ + + xmax = x->l_xcellnum - 1; + ymax = x->l_ycellnum - 1; + + post("life new...(%d X %d)", x->l_xcellnum, x->l_ycellnum); + for (j = 0; j <= ymax; j++) + { /* sets all cells to 0 */ + for (i = 0; i <= xmax; i++) + { + *(x->gen_origin_ptr+(j*x->l_xcellnum)+i) = 0; + *(x->gen_finale_ptr+(j*x->l_xcellnum)+i) = 0; + *(x->gen_start_ptr+(j*x->l_xcellnum)+i) = 0; + *(x->gen_shift_ptr+(j*x->l_xcellnum)+i) = 0; + } + } + + x->l_xshift = 0; + x->l_yshift = 0; + x->l_deltanum = 0; + x->l_lastdeltanum = 0; + x->l_novarinum = 32; + x->l_novar = 32; + + x->l_cellouts = getbytes(x->l_xcellnum*sizeof (t_outlet*)); + if (x->l_cellouts == NULL) + { + error("life2x_new: Unable to allocate %lu bytes for column outlets", + x->l_xcellnum*sizeof (t_outlet*)); + life2x_free (x); + return x; + } + + for (i = xmax; i >= 0; i--) x->l_cellouts[i] = outlet_new(&x->x_obj, &s_list);/* create an outlet for each column */ + x->l_deltaout = outlet_new(&x->x_obj, &s_float); /* create outlet for live cell diff from previous gen */ + x->l_liveout = outlet_new(&x->x_obj, &s_float); /* sets outlet for # of live cells in current generation */ + x->l_genout = outlet_new(&x->x_obj, &s_float); /* sets outlet for current generation # */ + x->l_dumpout = outlet_new(&x->x_obj, &s_list); /* sets outlet for list dumping */ + x->l_novariout = outlet_new(&x->x_obj, &s_bang); /* sets outlet for no variation period bang */ + x->l_deadout = outlet_new(&x->x_obj, &s_bang); /* sets first outlet for dead world bang */ + x->l_gennum = 0; /* sets first generation # */ + outlet_float(x->l_genout, x->l_gennum); + x->l_thruflag = 1; /* sets thru mode on */ + x->l_invertflag = 0; /* sets invert off */ + + /* set up default Conway rule */ + life2x_rule(x, gensym("23/3")); /* survive if 2 or 3 neighbours / born if 3 neighbours */ + srandom(clock()); /* seed the random number generator */ + return (x); +} + +/* end of life2x.c */ |