I'm trying to create a signal external with a variable number of inlets and outlets. As a test, I have written an object that copies its input to the respective output. When I put the object in a subpatch and use [block~] to change the block size, it crashes. Loading Pd with gdb gives the following output, which to me doesn't seem very helpful:

```
Program received signal SIGSEGV, Segmentation fault.
0x0000000000000000 in ?? ()
```

Here's the code of the object (the var_io_tilde_process function is there as a test to see if I can process the output in a routine other than the perform one):

```

#include <m_pd.h>

static t_class *var_io_tilde_class;

typedef struct _var_io_tilde {
	t_object obj;
	t_sample f;
	t_sample **in;
	t_sample **out;
	t_sample *buf;
	int chnls;
	int blksize;
	int bufbytes;
} t_var_io_tilde;

static void var_io_tilde_process(t_var_io_tilde *x, int n)
{
	int i, j;
	t_sample **out = x->out;
	t_sample *buf = x->buf;
	for (i = 0; i < x->chnls; i++) {
		for (j = 0; j < n; j++) {
			out[i][j] = buf[i*n+j];
		}
	}
}

t_int *var_io_tilde_perform(t_int *w)
{
	int i, j, n;
	t_var_io_tilde *x = (t_var_io_tilde *)(w[1]);
	n = (int)(w[2]);
	t_sample **in = x->in;
	//t_sample **out = x->out;
	t_sample *buf = x->buf;

	for (i = 0; i < x->chnls; i++) {
		for (j = 0; j < n; j++) {
			buf[i*n+j] = in[i][j];
		}
	}
	var_io_tilde_process(x, n);
	return (w+3);
}

void var_io_tilde_dsp(t_var_io_tilde *x, t_signal **sp)
{
	int i;
	int bufbytes = x->bufbytes;
	t_sample **dummy = x->in;
	for (i=0; i<x->chnls; i++)
		*dummy++ = sp[i]->s_vec;
	dummy = x->out;
	for (i=x->chnls; i<x->chnls*2; i++)
		*dummy++ = sp[i]->s_vec;

	if (x->blksize != sp[0]->s_n) {
		x->blksize = sp[0]->s_n;
		x->bufbytes = x->chnls*2*sp[0]->s_n;
		x->buf = (t_sample *)resizebytes((void *)x->buf, bufbytes, x->bufbytes);
		if (x->buf == NULL) {
			pd_error(x, "cannot realloc %d bytes of memory", x->bufbytes);
			return;
		}
	}
	dsp_add(var_io_tilde_perform, 2, x, sp[0]->s_n);
}

void *var_io_tilde_new(t_floatarg f)
{
	int i;
	t_var_io_tilde *x = (t_var_io_tilde *)pd_new(var_io_tilde_class);
	x->chnls = (f) ? f : 2;
	
	x->blksize = sys_getblksize();

	/* create signal inlets (first is done in var_io_tilde_setup) */
	for (i=1; i<x->chnls; i++)
		inlet_new(&x->obj, &x->obj.ob_pd, &s_signal, &s_signal);
	/* create signal outlets */
	for (i=0; i<x->chnls; i++)
		outlet_new(&x->obj, &s_signal);

	x->in = (t_sample **)getbytes(x->chnls * sizeof(t_sample **));
	x->out = (t_sample **)getbytes(x->chnls * sizeof(t_sample **));

	for (i=0; i<x->chnls; i++)
		x->in[i] = x->out[i] = 0;

	x->bufbytes = x->chnls*2*x->blksize;
	x->buf = (t_sample *)getbytes(x->bufbytes * sizeof(t_sample *));
	
	return (void *)x;
}

void var_io_tilde_free(t_var_io_tilde *x) {
	freebytes(x->in, sizeof(x->in));
	freebytes(x->out, sizeof(x->out));
}

void var_io_tilde_setup(void)
{
	var_io_tilde_class = class_new(gensym("var_io~"), (t_newmethod)var_io_tilde_new,
		(t_method)var_io_tilde_free, sizeof(t_var_io_tilde), CLASS_DEFAULT, A_DEFFLOAT, 0);
	class_addmethod(var_io_tilde_class, (t_method)var_io_tilde_dsp, gensym("dsp"), 0);
	CLASS_MAINSIGNALIN(var_io_tilde_class, t_var_io_tilde, f);
}

```

What am I doing wrong? And, if this is not the way, how can I create an object with a variable number of inlets and outlets (preferably independent of one another).