int C74_EXPORT main(void)
{
	t_class *c;
	
	c = class_new("hoa.pi~", (method)pi_new, (method)dsp_free, sizeof(t_pi), 0L, A_GIMME, 0);
	
	hoa_initclass(c, (method)hoa_getinfos);
    
	class_addmethod(c, (method)pi_dsp64,	"dsp64",    A_CANT, 0);
    class_addmethod(c, (method)pi_assist,	"assist",	A_CANT, 0);
	
    // @method int @digest Set π multiplier or phase
	// @description The <m>int</m> message set pi multiplier in the first inlet, the phase in the second one.
	// @marg 0 @name value @optional 0 @type int
    class_addmethod(c, (method)pi_int,		"int",		A_LONG, 0);
    
    // @method float @digest Set π multiplier or phase
	// @description The <m>float</m> message set pi multiplier in the first inlet, the phase in the second one.
	// @marg 0 @name value @optional 0 @type float
	class_addmethod(c, (method)pi_float,	"float",	A_FLOAT, 0);
	
    class_dspinit(c);
	class_register(CLASS_BOX, c);
	pi_class = c;
	return 0;
}

extern "C" int C74_EXPORT main(void)
{
	t_class *c;
	
	c = class_new("tap.count~",(method)count_tilde_new, (method)count_tilde_free, sizeof(t_count_tilde), (method)0L, A_GIMME, 0);

	common_symbols_init();
	
	class_addmethod(c, (method)count_tilde_reset, 	"reset", 0L);
	class_addmethod(c, (method)count_tilde_dsp64,	"dsp64", A_CANT, 0);
    class_addmethod(c, (method)count_tilde_assist, 	"assist", A_CANT, 0L); 
	class_addmethod(c, (method)stdinletinfo,		"inletinfo",	A_CANT, 0);
 
	CLASS_ATTR_LONG(c,		"high_bound",	0,	t_count_tilde, attr_high_bound);
	CLASS_ATTR_LONG(c,		"low_bound",	0,	t_count_tilde, attr_low_bound);
	
	CLASS_ATTR_LONG(c,		"active",		0,	t_count_tilde, attr_active);
	CLASS_ATTR_STYLE(c,		"active",		0,	"onoff");

	CLASS_ATTR_LONG(c,		"autoreset",	0,	t_count_tilde, attr_autoreset);
	CLASS_ATTR_STYLE(c,		"autoreset",	0,	"onoff");

	CLASS_ATTR_LONG(c,		"loop",			0,	t_count_tilde, attr_loop);
	CLASS_ATTR_STYLE(c,		"loop",			0,	"onoff");
	
	class_dspinit(c);									// Setup object's class to work with MSP
	class_register(_sym_box, c);
	count_tilde_class = c;
	return 0;
}

int TTCLASSWRAPPERMAX_EXPORT main(void)
{
	ClassPtr c;

	TTAudioGraphInit();	
	common_symbols_init();

	c = class_new("jcom.unpack≈", (method)UnpackNew, (method)UnpackFree, sizeof(Unpack), (method)0L, A_GIMME, 0);
	
	class_addmethod(c, (method)UnpackNotify,		"notify",			A_CANT, 0);
	class_addmethod(c, (method)UnpackReset,			"audio.reset",		A_CANT, 0);
	class_addmethod(c, (method)UnpackConnect,		"audio.connect",	A_OBJ, A_LONG, 0);
	class_addmethod(c, (method)MaxAudioGraphDrop,	"audio.drop",		A_CANT, 0);
	class_addmethod(c, (method)MaxAudioGraphObject,	"audio.object",		A_CANT, 0);
 	class_addmethod(c, (method)UnpackDsp64,			"dsp64",			A_CANT, 0);		
	class_addmethod(c, (method)UnpackAssist,		"assist",			A_CANT, 0); 
    class_addmethod(c, (method)object_obex_dumpout,	"dumpout",			A_CANT, 0);  
	
	//CLASS_ATTR_FLOAT(c,		"gain", 0,		Unpack,	gain);
	//CLASS_ATTR_ACCESSORS(c,	"gain",	NULL,	UnpackSetGain);

	class_dspinit(c);
	class_register(_sym_box, c);
	sUnpackClass = c;
	return 0;
}

int main(void)
{	

	t_class *c;
	
	c = class_new("hoa.encoder~", (method)HoaEncode_new, (method)HoaEncode_free, (long)sizeof(t_HoaEncode), 0L, A_GIMME, 0);
	
	class_addmethod(c, (method)HoaEncode_float,		"float",	A_FLOAT, 0);
	class_addmethod(c, (method)HoaEncode_int,		"int",		A_LONG, 0);
	class_addmethod(c, (method)HoaEncode_dsp,		"dsp",		A_CANT, 0);
	class_addmethod(c, (method)HoaEncode_dsp64,		"dsp64",	A_CANT, 0);
	class_addmethod(c, (method)HoaEncode_assist,	"assist",	A_CANT, 0);
	
	class_dspinit(c);				
	class_register(CLASS_BOX, c);	
	HoaEncode_class = c;

	if(class_findbyname(CLASS_NOBOX, gensym("hoa.loader")) == NULL)
	{
		if(postons == 0)
		{
			hoa_postcredits();
			postons = 1;
		}
	}
	return 0;
}

void send_tilde_initclass(void)
{
    long attrflags = 0;
    t_class *c;
    t_object *attr;

    // Define our class
    c = class_new("jcom.send~", (method)audiosend_new, (method)audiosend_free,
                  sizeof(t_audiosend), (method)NULL, A_GIMME, 0);

    // Make methods accessible for our class:
    class_addmethod(c, (method)audiosend_bang,			"bang",			0);
    class_addmethod(c, (method)audiosend_dsp,			"dsp", 			A_CANT, 0);
    class_addmethod(c, (method)audiosend_assist,		"assist", 		A_CANT, 0);
    class_addmethod(c, (method)object_obex_dumpout, 	"dumpout", 		A_CANT,0);

    // ATTRIBUTE: name
    attr = attr_offset_new("target", _sym_symbol, attrflags,
                           (method)0, (method)audiosend_attr_settarget, calcoffset(t_audiosend, attr_target));
    class_addattr(c, attr);

    // Setup our class to work with MSP
    class_dspinit(c);

    // Finalize our class
    class_register(CLASS_BOX, c);
    s_audiosend_class = c;
}

int TTCLASSWRAPPERMAX_EXPORT main(void)
{
	ClassPtr c;

	TTAudioGraphInit();	
	common_symbols_init();

	c = class_new("j.unsig=", (method)OutNew, (method)OutFree, sizeof(Out), (method)0L, A_GIMME, 0);
	
	class_addmethod(c, (method)OutNotify,			"notify",				A_CANT, 0);
	class_addmethod(c, (method)OutReset,			"audio.reset",		A_CANT, 0);
	class_addmethod(c, (method)OutConnect,			"audio.connect",	A_OBJ, A_LONG, 0);
	class_addmethod(c, (method)MaxAudioGraphDrop,	"audio.drop",		A_CANT, 0);
	class_addmethod(c, (method)MaxAudioGraphObject,	"audio.object",		A_CANT, 0);
 	class_addmethod(c, (method)OutDsp,				"dsp",					A_CANT, 0);		
	class_addmethod(c, (method)OutAssist,			"assist",				A_CANT, 0); 
    class_addmethod(c, (method)object_obex_dumpout,	"dumpout",				A_CANT, 0);  
	
	//CLASS_ATTR_FLOAT(c,		"gain", 0,		Out,	gain);
	//CLASS_ATTR_ACCESSORS(c,	"gain",	NULL,	OutSetGain);

	class_dspinit(c);
	class_register(_sym_box, c);
	sOutClass = c;
	return 0;
}

int TTCLASSWRAPPERMAX_EXPORT main(void)
{
	t_class *c;
	
	TTDSPInit();
	common_symbols_init();

	c = class_new("jcom.gain~", (method)gain_new, (method)gain_free, sizeof(t_gain), (method)0L, A_GIMME, 0);

	// Make methods accessible for our class: 
	class_addmethod(c, (method)gain_dsp, 				"dsp", A_CANT, 0L);
	class_addmethod(c, (method)gain_dsp64,				"dsp64", A_CANT, 0);
    class_addmethod(c, (method)object_obex_dumpout, 	"dumpout", A_CANT,0);
    class_addmethod(c, (method)gain_assist, 			"assist", A_CANT, 0L);

	CLASS_ATTR_CHAR(c,		"bypass",	0,		t_gain,	attrBypass);
	CLASS_ATTR_ACCESSORS(c,	"bypass",	NULL,	attr_set_bypass);
	
	CLASS_ATTR_FLOAT(c,		"mix",		0,		t_gain,	attrBypass);
	CLASS_ATTR_ACCESSORS(c,	"mix",		NULL,	attr_set_mix);
	
	CLASS_ATTR_FLOAT(c,		"gain",		0,		t_gain,	attrBypass);
	CLASS_ATTR_ACCESSORS(c,	"gain",		NULL,	attr_set_gain);
		
	// Setup our class to work with MSP
	class_dspinit(c);

	// Finalize our class
	class_register(CLASS_BOX, c);
	s_gain_class = c;
	return 0;
}

int C74_EXPORT main(void)
{	

	t_class *c;
	
	c = class_new("hoa.2d.optim~", (method)hoa_optim_new, (method)hoa_optim_free, (long)sizeof(t_hoa_optim), 0L, A_GIMME, 0);
	
    hoa_initclass(c, (method)hoa_getinfos);
	
	// @method signal @digest Array of circular harmonic signals to be optimized.
	// @description Array of circular harmonic signals to be optimized.
	class_addmethod(c, (method)hoa_optim_dsp64,		"dsp64",	A_CANT, 0);
	class_addmethod(c, (method)hoa_optim_assist,    "assist",	A_CANT, 0);
	
	// @method basic @digest Set the optimization mode to <b>basic</b>, does not apply any optimization.
	// @description Set the optimization mode to <b>basic</b>. This is particulary suitable when the listener is ideally placed at the center of the loudspeaker arrangement, or for diffused soundfields.
	class_addmethod(c, (method)hoa_optim_basic,     "basic",	A_NOTHING, 0);
	
	// @method maxRe @digest Set the optimization mode to <b>maxRe</b>.
	// @description Set the optimization mode to <b>maxRe</b>. This is particulary suitable when the audience is confined at the center of the restitution area.
    class_addmethod(c, (method)hoa_optim_maxre,     "maxRe",	A_NOTHING, 0);
	
	// @method maxRe @digest Set the optimization mode to <b>maxRe</b>.
	// @description Set the optimization mode to <b>maxRe</b>. This is particulary suitable when the audience covers all of the restitution area.
    class_addmethod(c, (method)hoa_optim_inphase,   "inPhase",	A_NOTHING, 0);
    
	class_dspinit(c);
	class_register(CLASS_BOX, c);	
	hoa_optim_class = c;
    
	return 0;
}

int C74_EXPORT main(void) {
    t_class *c;             //Variable to store the class
    c = class_new("FMgrains3~", (method) FMNew, (method) FMfree, sizeof(fmsynth), 0L, A_GIMME, 0);
    
    class_addmethod(c, (method) FMDsp64, "dsp64", A_CANT, 0);
    class_addmethod(c, (method) FMminFreq, "float", A_FLOAT, 0);
    class_addmethod(c, (method) FMmaxFreq, "ft1", A_FLOAT, 0);
    class_addmethod(c, (method) FMminModFreq, "ft2", A_FLOAT, 0);
    class_addmethod(c, (method) FMmaxModFreq, "ft3", A_FLOAT, 0);
    class_addmethod(c, (method) FMIndex, "ft4", A_FLOAT, 0);
    class_addmethod(c, (method) FMminWin, "ft5", A_FLOAT, 0);
    class_addmethod(c, (method) FMmaxWin, "ft6", A_FLOAT, 0);
    class_addmethod(c, (method) FMAssist, "assist", A_CANT, 0);
    class_addmethod(c, (method) FMSet, "set", A_SYM, 0);
    class_dspinit(c);
	class_register(CLASS_BOX, c);
    //Make symbols to assign to global variables for carrier
    sineMess = gensym("sine");
    squareMess = gensym("square");
    sawMess = gensym("saw");
    phasorMess = gensym("phasor");
    triMess = gensym("triangle");
    //Make symbols to assign to global variables for modulator
    sineMessMod = gensym("sinemod");
    squareMessMod = gensym("squaremod");
    sawMessMod = gensym("sawmod");
    phasorMessMod = gensym("phasormod");
    triMessMod = gensym("trianglemod");
    myClass = c;
    return 0;
}

// initialization routine
int C74_EXPORT main (void)
{
    drag_class = class_new("db.drag~", (method)drag_new, (method)drag_dsp_free,
                           sizeof(t_drag), 0L, A_GIMME, 0);

    // register methods to handle incoming messages
    class_addmethod(drag_class, (method)drag_dsp64, "dsp64", A_CANT, 0);
    class_addmethod(drag_class, (method)drag_assist, "assist", A_CANT, 0);
    class_addmethod(drag_class, (method)drag_bang, "bang", A_FLOAT, 0);
    class_addmethod(drag_class, (method)drag_float, "float", A_FLOAT, 0);
    class_addmethod(drag_class, (method)drag_dcblock_set, "dc", A_GIMME, 0);
    class_addmethod(drag_class, (method)drag_shape_set, "shape", A_GIMME, 0);
    class_addmethod(drag_class, (method)drag_fmax_set, "fmax", A_GIMME, 0);
    class_addmethod(drag_class, (method)drag_drag_set, "drag", A_GIMME, 0);
    class_addmethod(drag_class, (method)drag_dragcurv_set, "dragcurve", A_GIMME, 0);

    class_dspinit(drag_class);
    class_register(CLASS_BOX, drag_class);

    post("db.drag~ by Daniel Bennett [email protected]");
    post("- Peter Blasser inspired Triangle \"drag & Bounds\" oscillators");
    post("args:- 1) no of voices (default 1 - henceforth \"n\") ");
    post("args:- 2) Lower bound for voice 1 (default -1)");
    post("args:- 3) Upper bound for voice n (default 1) ");
    post("args:- 4) mode -  ");

    // report to the MAX window
    return 0;
}

int C74_EXPORT main(void)
{	

	t_class *c;
	
	c = class_new("hoa.optim~", (method)HoaOptim_new, (method)dsp_free, (long)sizeof(t_HoaOptim), 0L, A_GIMME, 0);
	
	class_addmethod(c, (method)HoaOptim_dsp64,		"dsp64",	A_CANT, 0);
	class_addmethod(c, (method)HoaOptim_assist,		"assist",	A_CANT, 0);
    
    CLASS_ATTR_SYM				(c, "optim", 0, t_HoaOptim, f_optim_mode);
	CLASS_ATTR_CATEGORY			(c, "optim", 0, "Behavior");
	CLASS_ATTR_LABEL			(c, "optim", 0, "Optimization");
    CLASS_ATTR_ENUM             (c, "optim", 0, "basic maxRe inPhase");
	CLASS_ATTR_ORDER			(c, "optim", 0, "1");
	CLASS_ATTR_ACCESSORS		(c, "optim", NULL, HoaOptim_optim);
	CLASS_ATTR_SAVE				(c, "optim", 1);
	
	class_dspinit(c);				
	class_register(CLASS_BOX, c);	
	HoaOptim_class = c;
	
	class_findbyname(CLASS_BOX, gensym("hoa.encoder~"));
	return 0;
}

extern "C" int C74_EXPORT main(void)
{
	t_class *c;
	
	c = class_new("tap.shift~",(method)shift_new, (method)shift_free, sizeof(t_shift), 
		(method)0L, A_GIMME, 0);

		common_symbols_init();								// Initialize TapTools

	// ADD ATTRIBUTES
	CLASS_ATTR_DOUBLE(c,		"ratio",			0,	t_shift, attr_ratio);
	CLASS_ATTR_ACCESSORS(c,	"ratio",			NULL, attr_set_ratio);

	CLASS_ATTR_DOUBLE(c,		"window_size",		0,	t_shift, attr_window_size);
	CLASS_ATTR_ACCESSORS(c,	"window_size",		NULL, attr_set_window_size);

	// ADD METHODS
	class_addmethod(c, (method)shift_float, 	"float", 	A_FLOAT, 0L);
	class_addmethod(c, (method)shift_int,	 	"int", 		A_LONG, 0L);
	class_addmethod(c, (method)shift_clear, 	"clear", 	0L);
	class_addmethod(c, (method)shift_dsp64, "dsp64", A_CANT, 0);
    class_addmethod(c, (method)shift_assist, 	"assist", 	A_CANT, 0L); 
	class_addmethod(c, (method)stdinletinfo,	"inletinfo",	A_CANT, 0);

	// WRAP UP
    class_dspinit(c);									// Setup object's class to work with MSP
class_register(_sym_box, c); 	shift_class = c;
}

void ext_main(void *r)
{
	
	t_class *c = class_new("ambipan~", 
						   (method)ambipan_tilde_new, 
						   (method)ambipan_tilde_dest, 
						   (short)sizeof(t_ambipan_tilde), NULL, A_GIMME, 0);

	//-------------D�finition des m�thodes-------------------//
	class_addmethod(c, (method)ambipan_tilde_dsp64, "dsp64", A_CANT, 0);
	class_addmethod(c, (method)ambipan_tilde_recoit_liste, "list", A_GIMME, 0);
	class_addmethod(c, (method)ambipan_tilde_recoit_float, "float", A_FLOAT, 0);
	class_addmethod(c, (method)ambipan_tilde_initialiser_nb_hp, "set_nb_hp", A_LONG, 0);
	class_addmethod(c, (method)ambipan_tilde_teta_positionner_hp, "a_setpos", A_GIMME, 0);
	class_addmethod(c, (method)ambipan_tilde_dist_teta_positionner_hp, "ra_setpos", A_GIMME, 0);
	class_addmethod(c, (method)ambipan_tilde_xy_positionner_hp, "xy_setpos", A_GIMME, 0);
	class_addmethod(c, (method)ambipan_tilde_changer_offset, "set_offset", A_FLOAT, 0);
	class_addmethod(c, (method)ambipan_tilde_muter_entrees_signal, "mute_sig", A_LONG, 0);
	class_addmethod(c, (method)ambipan_tilde_changer_type_repere, "change_type", A_SYM, 0);
	class_addmethod(c, (method)ambipan_tilde_informations, "get_info", 0);
	class_addmethod(c, (method)ambipan_tilde_assist,"assist",A_CANT,0);	
	
    cicmtools_post_credits();
	
	class_dspinit(c);
	class_register(CLASS_BOX, c);
    ambipan_tilde_class = c;
}

int C74_EXPORT main(void)
{	
	t_class *c;
	
	c = class_new("hoa.binaural~", (method)HoaBinaural_new, (method)HoaBinaural_free, (long)sizeof(t_HoaBinaural), 0L, A_GIMME, 0);
	
	class_addmethod(c, (method)HoaBinaural_dsp,			"dsp",		A_CANT,		0);
	class_addmethod(c, (method)HoaBinaural_dsp64,		"dsp64",	A_CANT,		0);
	class_addmethod(c, (method)HoaBinaural_assist,		"assist",	A_CANT,		0);
    
    CLASS_ATTR_SYM              (c,"pinnasize", 0,      t_HoaBinaural, f_pinna_size);
    CLASS_ATTR_ACCESSORS		(c,"pinnasize", NULL,   HoaBinaural_set_pinnasize);
	CLASS_ATTR_LABEL			(c,"pinnasize", 0,      "Pinna Size");
	CLASS_ATTR_CATEGORY			(c,"pinnasize", 0,      "Behavior");
    CLASS_ATTR_ENUM             (c,"pinnasize", 0,      "small large");
	CLASS_ATTR_DEFAULT          (c,"pinnasize", 0,      "small");
    CLASS_ATTR_ORDER			(c,"pinnasize", 0,      "1");
    CLASS_ATTR_SAVE             (c,"pinnasize", 1);
	
	class_dspinit(c);				
	class_register(CLASS_BOX, c);	
	HoaBinaural_class = c;
	
	class_findbyname(CLASS_NOBOX, gensym("hoa.encoder~"));
	return 0;
}

int main(void)
{
	t_class *c = class_new("o.edge~", (method)oedge_new, (method)oedge_free, sizeof(t_oedge), 0L, A_GIMME, 0);
	//class_addmethod(c, (method)oedge_fullPacket, "FullPacket", A_LONG, A_LONG, 0);
	//class_addmethod(c, (method)oedge_fullPacket, "FullPacket", A_GIMME, 0);
	class_addmethod(c, (method)oedge_assist, "assist", A_CANT, 0);
	class_addmethod(c, (method)oedge_doc, "doc", 0);
    	class_addmethod(c, (method)oedge_dsp, "dsp", A_CANT, 0);
    	class_addmethod(c, (method)oedge_dsp64, "dsp64", A_CANT, 0);
	//class_addmethod(c, (method)oedge_bang, "bang", 0);
	//class_addmethod(c, (method)oedge_anything, "anything", A_GIMME, 0);
	// remove this if statement when we stop supporting Max 5
	//if(omax_dict_resolveDictStubs()){
	//class_addmethod(c, (method)omax_dict_dictionary, "dictionary", A_GIMME, 0);
	//}
	class_addmethod(c, (method)odot_version, "version", 0);
	
    	class_dspinit(c);

	class_register(CLASS_BOX, c);
	oedge_class = c;

	common_symbols_init();

	ODOT_PRINT_VERSION;

	omax_realtime_clock_init();
	return 0;
}

extern "C" int TTCLASSWRAPPERMAX_EXPORT main(void)
{
	t_class *c;

	c = class_new("tap.decibels~",(method)decibels_new, (method)dsp_free, sizeof(t_decibels), 
		(method)0L, A_GIMME, 0);

		common_symbols_init();
	class_addmethod(c, (method)decibels_dsp, 			"dsp", A_CANT, 0L);		
	class_addmethod(c, (method)decibels_dsp64, "dsp64", A_CANT, 0);
    class_addmethod(c, (method)decibels_int, 			"int", A_LONG, 0L);		// Input as int
    class_addmethod(c, (method)decibels_float, 			"float", A_FLOAT, 0L);	// Input as double
    class_addmethod(c, (method)decibels_assist, 		"assist", A_CANT, 0L); 
	class_addmethod(c, (method)stdinletinfo,			"inletinfo",	A_CANT, 0);

	CLASS_ATTR_SYM(c,		"mode",			0,	t_decibels, attr_mode);
	CLASS_ATTR_ACCESSORS(c,	"mode",			NULL, attr_set_mode);
	CLASS_ATTR_ENUM(c,		"mode",			0,	"amp2db db2amp mm2db db2mm mm2amp amp2mm db2midi midi2db");

	class_dspinit(c);									// Setup object's class to work with MSP
class_register(_sym_box, c); 	decibels_class = c;

	// initialize class globals
	ps_amp2db = gensym("amp2db");
	ps_db2amp = gensym("db2amp");
	ps_mm2db = gensym("mm2db");
	ps_db2mm = gensym("db2mm");
	ps_mm2amp = gensym("mm2amp");
	ps_amp2mm = gensym("amp2mm");
	ps_db2midi = gensym("db2midi");
	ps_midi2db = gensym("midi2db");
}

int C74_EXPORT main(void)
{	

	t_class *c;
	
	c = class_new("hoa.3d.wider~", (method)hoa_wider_new, (method)hoa_wider_free, (long)sizeof(t_hoa_wider), 0L, A_GIMME, 0);
	
	hoa_initclass(c, (method)hoa_getinfos);
	
	// @method float @digest Set the widening value.
	// @description Set the widening value in the last inlet at control rate. The widening value is clipped between 0. and 1.
	class_addmethod(c, (method)hoa_wider_float,		"float",	A_FLOAT, 0);
	
	// @method int @digest Set the widening value.
	// @description Set the widening value in the last inlet at control rate. The widening value is clipped between 0. and 1.
	class_addmethod(c, (method)hoa_wider_int,       "int",		A_LONG, 0);
	
	// @method signal @digest Array of spherical harmonics signals to be processed, widening value.
	// @description Array of spherical harmonics signals to be processed. Set the widening value in the last inlet at signal rate. The widening value is clipped between 0. and 1.
	class_addmethod(c, (method)hoa_wider_dsp64,		"dsp64",	A_CANT, 0);
	class_addmethod(c, (method)hoa_wider_assist,    "assist",	A_CANT, 0);
	
	class_dspinit(c);
	class_register(CLASS_BOX, c);	
	hoa_wider_class = c;
	return 0;
}

/********************************************************************************
int main(void)

inputs:			nothing
description:	called the first time the object is used in MAX environment; 
		defines inlets, outlets and accepted messages
returns:		int
********************************************************************************/
int C74_EXPORT main(void)
{
    t_class *c;
    
    c = class_new(OBJECT_NAME, (method)gverb_new, (method)gverb_free,
			(short)sizeof(t_gverb), 0L, A_DEFFLOAT, 0);
    class_dspinit(c); // add standard functions to class
    
    class_addmethod(c, (method)gverb_dsp, "dsp", A_CANT, 0);
	
	/* bind method "gverb_float" to incoming floats */
	class_addmethod(c, (method)gverb_float, "float", A_FLOAT, 0);
	
	/* bind method "gverb_int" to incoming ints */
	class_addmethod(c, (method)gverb_int, "int", A_LONG, 0);
	
	/* bind method "gverb_assist" to the assistance message */
	class_addmethod(c, (method)gverb_assist, "assist", A_CANT, 0);
	
	/* bind method "gverb_getinfo" to the getinfo message */
	class_addmethod(c, (method)gverb_getinfo, "getinfo", A_NOTHING, 0);
    
    /* bind method "gverb_dsp64" to the dsp64 message */
    class_addmethod(c, (method)gverb_dsp64, "dsp64", A_CANT, 0);
    
    class_register(CLASS_BOX, c); // register the class w max
    gverb_class = c;
	
    #ifdef DEBUG
        post("%s: main function was called", OBJECT_NAME);
    #endif /* DEBUG */
    
    return 0;
}

int C74_EXPORT main(void)
{
    t_class *c = class_new("rtlsdr~", (method)rtlsdr_new, (method)rtlsdr_free, sizeof(t_rtlsdr), NULL, A_DEFFLOAT, 0);
    
    // this needs to be here even if we don't need to input any signals...
    class_addmethod(c, (method)rtlsdr_dsp64, "dsp64", A_CANT, 0); 	// respond to the dsp message
    
    class_addmethod(c, (method)rtlsdr_float, "float", A_FLOAT, 0);
    class_addmethod(c, (method)rtlsdr_int, "int", A_LONG, 0);
    
    class_addmethod(c, (method)rtlsdr_freq, "freq", A_GIMME, 0 );
    class_addmethod(c, (method)rtlsdr_gain, "gain", A_GIMME, 0 );
    class_addmethod(c, (method)rtlsdr_samplerate, "samplerate", A_GIMME, 0 );
    class_addmethod(c, (method)rtlsdr_resetbuf, "resetbuf", 0);
    class_addmethod(c, (method)rtlsdr_stop, "stop", 0);
    class_addmethod(c, (method)rtlsdr_start, "start", 0);
    class_addmethod(c, (method)rtlsdr_info, "info", 0);
    
    //    class_addmethod(c, (method)rtlsdr_bang,"bang", BANG, 0);
    
    // need to add message input here...
    
    class_addmethod(c, (method)rtlsdr_assist,"assist",A_CANT,0);
    
    class_dspinit(c);												// must call this function for MSP object classes
    
	class_register(CLASS_BOX, c);
	rtlsdr_class = c;
    
    
	return 0;
}

int C74_EXPORT main()
{
    this_class = class_new ("ibufconcatenate~",
							(method) ibufconcatenate_new, 
							(method)ibufconcatenate_free, 
							sizeof(t_ibufconcatenate), 
							0L, 
							A_SYM, 
							A_DEFLONG,
							0);
	
	class_addmethod (this_class, (method)ibufconcatenate_int, "int", A_LONG, 0L);
	class_addmethod (this_class, (method)ibufconcatenate_set, "set", A_SYM, 0L);
	class_addmethod (this_class, (method)ibufconcatenate_clear, "clear", 0L);
	class_addmethod (this_class, (method)ibufconcatenate_append, "append", A_SYM, 0L);
    class_addmethod (this_class, (method)ibufconcatenate_entry, "entry", A_DEFFLOAT, A_DEFFLOAT, 0L);
	class_addmethod (this_class, (method)ibufconcatenate_assist, "assist", A_CANT, 0L);
	class_addmethod(this_class, (method)ibufconcatenate_dsp, "dsp", A_CANT, 0);
	class_addmethod(this_class, (method)ibufconcatenate_dsp64, "dsp64", A_CANT, 0);
	
	class_register(CLASS_BOX, this_class);
	
	class_dspinit(this_class);
			
	return 0;
}