path: root/src/chord.c

/* ------------------------- chord   ------------------------------------------ */
/*                                                                              */
/* Tries to detect a chord (or any harmonic relations) of incoming notes.       */
/* Written by Olaf Matthes (olaf.matthes@gmx.de)                                */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/               */
/*                                                                              */
/* This program is free software; you can redistribute it and/or                */
/* modify it under the terms of the GNU General Public License                  */
/* as published by the Free Software Foundation; either version 2               */
/* of the License, or (at your option) any later version.                       */
/*                                                                              */
/* This program is distributed in the hope that it will be useful,              */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of               */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
/* GNU General Public License for more details.                                 */
/*                                                                              */
/* You should have received a copy of the GNU General Public License            */
/* along with this program; if not, write to the Free Software                  */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.  */
/*                                                                              */
/* Based on PureData by Miller Puckette and others.                             */
/*                                                                              */
/* ---------------------------------------------------------------------------- */

#include "m_pd.h"
#include <stdio.h>
#include <string.h>

#define MAX_POLY 32                 /* maximum number of notes played at a time */

#define kUnison 0
#define kMaj 1
#define kMin 2
#define kDim 3
#define kAug 4
#define kMaj7 5
#define kDom7  6
#define kMin7  7
#define kHalfDim7 8
#define kDim7  9
#define kMinMaj7 10
#define kMaj7s5  11
#define kMaj7b5  12
#define kDom7s5  13
#define kDom7b5  14
#define kDomb9 15
#define kMaj9  16
#define kDom9  17
#define kMin9  18
#define kHalfDim9 19
#define kMinMaj9  20
#define kDimMaj9  21
#define kMaj9b5  22
#define kDom9b5  23
#define kDom9b13  24
#define kMin9s11  25
#define kmM9b11  26
#define kMaj7b9  27
#define kMaj7s5b9  28
#define kDom7b9  29
#define kMin7b9  30
#define kMinb9s11  31
#define kHalfDimb9  32
#define kDim7b9 33
#define kMinMajb9 34 
#define kDimMajb9 35
#define kMaj7s9  36
#define kDom7s9  37
#define kMaj7s11  38
#define kMs9s11  39
#define kHDimb11 40
#define kMaj11  41
#define kDom11  42
#define kMin11  43
#define kHalfDim11 44  
#define kDim11  45
#define kMinMaj11 46 
#define kDimMaj11 47
#define kMaj11b5  48
#define kMaj11s5  49
#define kMaj11b9  50
#define kMaj11s9  51
#define kMaj11b13  52
#define kMaj11s13  53
#define kM11b5b9  54
#define kDom11b5  55
#define kDom11b9  56
#define kDom11s9  57
#define kHalfDim11b9 58
#define kDom7s11  59
#define kMin7s11  60
#define kDom13s11  61
#define kM7b913  62
#define kMaj7s13  63
#define kMaj9s13  64
#define kM7b9s13  65
#define kDom7b13  66
#define kChrom  67
#define kNone  68

#define kXX -1


static char *version = "chord v0.2, written by Olaf Matthes <olaf.matthes@gmx.de>";

static char* pitch_class[13] = {"C ", "Db ", "D ", "Eb ", "E ", "F ", "Gb ", "G ", "Ab ", "A ", "Bb ", "B ", "no root "};
static char name_class[7] = {'C', 'D', 'E', 'F', 'G', 'A', 'B'};

typedef struct {
	int  type;
	int  rootMember;
} t_type_root;
 
typedef struct chord
{
  t_object x_ob;
  t_outlet *x_outchordval;          /* chord as MIDI note number of base note */
  t_outlet *x_outchordclass;        /* class of chord's bass note */
  t_outlet *x_outchordname;         /* chord name, e.g. "Cmajor7" */
  t_outlet *x_outchordinversion;    /* inversion of the chord (root = 0, 1st = 1, 2nd = 2) */
  t_outlet *x_outchordnotes;        /* list with note numbers belonging to the chord */

  t_int    x_pitch;
  t_int    x_pc[12];                /* pitch class array */
  t_int    x_abs_pc[12];            /* pitch class array: absolute MIDI note numbers */
  t_int    x_velo;
  t_int    x_alloctable[MAX_POLY];  /* a table used to store all playing notes */
  t_int    x_poly;                  /* number of notes currently playing */
  t_atom   x_chordlist[12];			/* list that stores the note numbers for output */
  t_int    x_split;                 /* highes note number to process */

  t_int    x_chord_type;			/* chord's type (number between 0 and 68) */
  t_int    x_chord_root;            /* chord's root (pitch class) */
  t_int    x_chord_bass;            /* chord's bass note (MIDI note number) */
  t_int    x_chord_inversion;       /* chord's state of inversion (root, 1st, 2nd) */

} t_chord;

/* functions */
static void chord_kick_out_member(t_chord *x, t_int number, t_int *members);
static void chord_chord_finder(t_chord *x, t_int num_pcs);
static void chord_draw_chord_type(t_chord *x, t_int num_pcs);


static void chord_unison(t_chord *x)
{
	int i;
	int member = 0;
	for(i = 0; i < 12; i++)
		if(x->x_pc[i])
		{
			member = i;				// find pitch class
			break;
		}
	x->x_chord_type  = 0;
	x->x_chord_root  = member;
	chord_draw_chord_type(x, 1);				// output onto the screen
}

static void chord_dyad(t_chord *x)
{
	static t_type_root dyads[11] = 
	 {{ kMaj7,  1 }, { kDom7, 1 }, { kMin, 0 }, { kMaj, 0 }, { kMaj,  1 },
	  { kDom7 , 0 }, { kMaj,  0 }, { kMaj, 1 }, { kMin, 1 }, { kDom7, 0 }, { kMaj7,  0 }};
	register t_type_root* t;

	int members[2];
	int i, j = 0;
	int interval1;

	for(i = 0; i < 12; i++)
		if(x->x_pc[i]) members[j++] = i;		/* load members array with chord pitch classes */
	interval1 = members[1] - members[0];		/* calculate interval between first two members */
	interval1 = interval1 - 1;					/* reduce interval1 to start at zero */
	t = &(dyads[interval1]);					/* find TypeRoot struct for this interval */
	x->x_chord_type = t->type;
	if (interval1 == 5)
		x->x_chord_root = (members[0]+8)%12;
	else
		x->x_chord_root = members[t->rootMember];
	x->x_chord_inversion = t->rootMember;		/* get state of inversion */
	chord_draw_chord_type(x, 2);				/* output results */
}

static void chord_triad(t_chord *x)
{
	static t_type_root triads[10][10] = 
	{/* interval1 is a half step			*/
	 {{ kMaj7b9,   1 }, { kMaj9,     1 }, { kMinMaj7, 1 }, { kMaj7,     1 }, { kDom7s11,2 },
	  { kDomb9 ,   0 }, { kMaj7,     1 }, { kMaj7s5,  1 }, { kMin9,     2 }, { kMaj7b9, 0 }},
	 /* interval1 is a whole step			*/
	 {{ kMin9,     0 }, { kDom9,     0 }, { kMin7,    1 }, { kDom7,     1 }, { kDom9,   0 },
	  { kHalfDim7, 1 }, { kDom7,     1 }, { kDom9,    0 }, { kMaj9,     0 }},
	 /* interval1 is a minor third			*/
	 {{ kMaj7s5,   2 }, { kDom7,     2 }, { kDim,     0 }, { kMin,      0 }, { kMaj,    2 },
	  { kDim,      2 }, { kMin7,     0 }, { kMinMaj7, 0 }},
	 /* interval1 is a major third			*/
	 {{ kMaj7,     2 }, { kHalfDim7, 2 }, { kMaj,     0 }, { kAug,      0 }, { kMin,    2 },
	  { kDom7,     0 }, { kMaj7,     0 }},
	 /* interval1 is a perfect fourth		*/
	 {{ kDomb9,    1 }, { kDom9,     1 }, { kMin,     1 }, { kMaj,      1 }, { kDom9,   2 },
	  { kDom7s11,  1 }},
	 /* interval1 is an augmented fourth	*/
	 {{ kDom7s11,  0 }, { kDom7,     2 }, { kDim,     1 }, { kHalfDim7, 0 }, { kDomb9,  2 }},
	 /* interval1 is a perfect fifth		*/
	 {{ kMaj7,     2 }, { kMin7,     2 }, { kDom7,    0 }, { kMaj7,     0 }},
	 /* interval1 is a minor sixth			*/
	 {{ kMinMaj7,  2 }, { kDom9,     1 }, { kMaj7s5,  0 }},
	 /* interval1 is a major sixth			*/
	 {{ kMaj9,     2 }, { kMin9,     1 }},
	 /* interval1 is a minor seventh		*/
	 {{ kMaj7b9,   2 }}
	};
	register t_type_root* t;
	
	int members[3];
	int i, j = 0;
	int interval1, interval2;

	for(i = 0; i < 12; i++)
		if(x->x_pc[i]) members[j++] = i;		/* load members array with chord pitch classes */
	interval1 = members[1] - members[0];		/* calculate interval between first two members */
	interval2 = members[2] - members[0];		/* calculate interval between first and third */
	interval2 = interval2 - interval1 - 1;		/* reduce interval2 to start at zero */
	interval1 = interval1 - 1;					/* reduce interval1 to start at zero */
	t = &(triads[interval1][interval2]);		/* find TypeRoot struct for this interval vector */
	x->x_chord_type = t->type;
	x->x_chord_root = members[t->rootMember];
	switch(t->rootMember) {						/* get state of inversion */
			case 0: 
				x->x_chord_inversion = 0;
				break;
			case 1: 
				x->x_chord_inversion = 2;
				break;
			case 2: 
				x->x_chord_inversion = 1;
	}
	chord_draw_chord_type(x, 3);				/* output onto the screen */
}

static void chord_quartad(t_chord *x)
{
	static t_type_root quartads[9][9][9] =
	{
	 {/* interval1 is a half step			*/
	   {/* interval2 is a whole step		*/
		{ kM7b9s13, 2 }, { kMinMajb9,1 }, { kMaj7b9,   1 }, { kMaj7s13,  2 }, { kDimMajb9, 1 },
		{ kMaj7b9,  1 }, { kMaj7s13, 2 }, { kM7b913,   1 }, { kM7b9s13,  1 }},
	   {/* interval2 is a minor third		*/
		{ kMinMaj9, 1 }, { kMaj9,    1 }, { kHalfDimb9,0 }, { kMin7b9,   0 }, { kMaj9,     1 },
		{ kDim7b9,  0 }, { kMin7b9,  0 }, { kMinMajb9, 0 }},
	   {/* interval2 is a major third		*/
		{ kMaj7s9,  1 }, { kDom7s11, 3 }, { kDomb9,    0 }, { kMinMaj7,  1 }, { kDom7s9,   3 },
		{ kDomb9,   0 }, { kMaj7b9,  0 }},
	   {/* interval2 is a perfect fourth	*/
		{ kMaj11,   1 }, { kMaj7b5,  1 }, { kMaj7,     1 }, { kMaj7s5,   1 }, { kMin9,     3 },
		{ kMaj7s13, 1 }},
	   {/* interval2 is a tritone			*/
		{ kDimMaj9, 3 }, { kDom11,   3 }, { kDim7b9,   0 }, { kHalfDimb9,0 }, { kDimMajb9, 0 }},
	   {/* interval2 is a perfect fifth		*/
		{ kMaj11,   3 }, { kDom7s9,  3 }, { kDomb9,    0 }, { kMaj7b9,   0 }},
	   {/* interval2 is a minor sixth		*/
		{ kMaj7s9,  3 }, { kMin9,    3 }, { kMaj7s13,  1 }},
	   {/* interval2 is a major sixth		*/
		{ kMinMaj9, 3 }, { kM7b913,  0 }},
	   {/* interval2 is a minor seventh		*/
		{ kM7b9s13, 0 }}
	 },
	 {/* interval1 is a whole step			*/
	   {/* interval2 is a minor third		*/
		{ kM7b913,   2 }, { kMin7b9, 1 }, { kDomb9,    1 }, { kMin9,     0 }, { kHalfDimb9,1 },
		{ kDomb9,    1 }, { kMin9,   0 }, { kMinMaj9,  0 }},
	   {/* interval2 is a major third		*/
		{ kMin9,     1 }, { kDom9,   1 }, { kDom9,     0 }, { kDom7s5,   2 }, { kDom9,     1 },
		{ kDom9,     0 }, { kMaj9,   0 }},
	   {/* interval2 is a perfect fourth	*/
		{ kDom7s9,   1 }, { kDom11,  3 }, { kHalfDim7, 1 }, { kMin7,     1 }, { kDom9,     3 },
		{ kHalfDimb9,3 }},
	   {/* interval2 is a tritone			*/
		{ kDom11,    1 }, { kDom7b5, 3 }, { kDom7,     1 }, { kDom7s5,   1 }, { kMin7b9,   3 }},
	   {/* interval2 is a perfect fifth		*/
		{ kMaj7b5,   3 }, { kDom11,  1 }, { kDom9,     0 }, { kMaj9,     0 }},
	   {/* interval2 is a minor sixth		*/
		{ kDom7s11,  1 }, { kDom9,   3 }, { kDim7b9,   3 }},
	   {/* interval2 is a major sixth		*/
		{ kMaj9,     3 }, { kMin7b9, 3 }},
	   {/* interval2 is a minor seventh		*/
		{ kMinMajb9, 3 }}
	 },
	 {/* interval1 is a minor third			*/
	   {/* interval2 is a major third		*/
		{ kMaj7s13,  3 }, { kDim7b9,  1 }, { kDom7s9,   0 }, { kMaj7s5,   2 }, { kDim7b9,   1 },
		{ kDom7s9,   0 }, { kMaj7s9,  0 }},
	   {/* interval2 is a perfect fourth	*/
		{ kDomb9,    2 }, { kDom9,    2 }, { kMin7,     2 }, { kDom7,     2 }, { kDom11,    2 },
		{ kDom7s11,  2 }},
	   {/* interval2 is a tritone			*/
		{ kDim7b9,   2 }, { kDom7,    3 }, { kDim7,     0 }, { kHalfDim7, 0 }, { kDomb9,    3 }},
	   {/* interval2 is a perfect fifth		*/
		{ kMaj7,     3 }, { kHalfDim7,3 }, { kMin7,     0 }, { kMinMaj7,  0 }},
	   {/* interval2 is a minor sixth		*/
		{ kDomb9,    2 }, { kDom9,    2 }, { kDom7s9,   2 }},
	   {/* interval2 is a major sixth		*/
		{ kHalfDimb9,2 }, { kDomb9,   3 }},
	   {/* interval2 is a minor seventh		*/
		{ kMaj7b9,   3 }}
	 },
	 {/* interval1 is a major third			*/
	   {/* interval2 is a perfect fourth	*/
		{ kMaj7b9,   2 }, { kMaj9,    2 }, { kMinMaj7,   2 }, { kMaj7,     2 }, { kDom11,  0 },
		{ kMaj11,    0 }},
	   {/* interval2 is a tritone			*/
		{ kHalfDimb9,2 }, { kDom7s5,  3 }, { kHalfDim7,  2 }, { kDom7b5,   0 }, { kMaj7b5, 0 }},
	   {/* interval2 is a perfect fifth		*/
		{ kMaj7s5,   3 }, { kMin7,    3 }, { kDom7,      0 }, { kMaj7,     0 }},
	   {/* interval2 is a minor sixth		*/
		{ kMinMaj7,  3 }, { kDom7s5,  0 }, { kMaj7s5,    0 }},
	   {/* interval2 is a major sixth		*/
		{ kMin7b9,   2 }, { kMin9,    2 }},
	   {/* interval2 is a minor seventh		*/
		{ kMaj7s13,  0 }}
	 },
	 {/* interval1 is a perfect fourth		*/
	   {/* interval2 is a tritone			*/
		{ kDimMajb9, 2 }, { kMin7b9, 1 }, { kDomb9,  1 }, { kMaj7b5,  2 }, { kDimMaj9, 0 }},
	   {/* interval2 is a perfect fifth		*/
		{ kMin9,     1 }, { kDom9,   1 }, { kDom11,  0 }, { kDom11,   2 }},
	   {/* interval2 is a minor sixth		*/
		{ kDom7s9,   1 }, { kDom9,   3 }, { kDim7b9, 3 }},
	   {/* interval2 is a major sixth		*/
		{ kMaj9,     3 }, { kHalfDimb9,3 }},
	   {/* interval2 is a minor seventh		*/
		{ kDimMajb9, 3 }}
	 },
	 {/* interval1 is a tritone				*/
	   {/* interval2 is a perfect fifth		*/
		{ kMaj7s13,  3 }, { kHalfDimb9,1 }, { kDom7s11, 0 }, { kMaj11,   2 }},
	   {/* interval2 is a minor sixth		*/
		{ kDomb9,    2 }, { kDom9,     2 }, { kDom7s9,  2 }},
	   {/* interval2 is a major sixth		*/
		{ kDim7b9,   2 }, { kDomb9,    3 }},
	   {/* interval2 is a minor seventh		*/
		{ kMaj7b9,   3 }}
	 },
	 {/* interval1 is a perfect fifth		*/
	   {/* interval2 is a minor sixth		*/
		{ kMaj7b9,    2 }, { kMaj9,    2 }, { kMaj7s9,   2 }},
	   {/* interval2 is a major sixth		*/
		{ kMin7b9,    2 }, { kMin9,    2 }},
	   {/* interval2 is a minor seventh		*/
		{ kMaj7s13,   0 }}
	 },
	 {/* interval1 is a minor sixth			*/
	   {/* interval2 is a major sixth		*/
		{ kMinMajb9,  2 }, { kMinMaj9, 2 }},
	   {/* interval2 is a minor seventh		*/
		{ kM7b913,    3 }}
	 },
	 {/* interval1 is a major sixth			*/
	   {/* interval2 is a minor seventh		*/
		{ kM7b9s13,   2 }}
	 }
	};

	register t_type_root* t;
	
	int members[4];
	int interval1, interval2, interval3;
	int i, j = 0;
	for (i=0; i<12; i++)
		if (x->x_pc[i]) members[j++] = i;		/* load members array with chord pitch classes */
	interval1 = members[1] - members[0];		/* calculate interval between first two members */
	interval2 = members[2] - members[0];		/* calculate interval between first and third */
	interval3 = members[3] - members[0];		/* calculate interval between first and third */
	interval3 = interval3 - interval2 - 1;		/* reduce interval3 to start at zero */
	interval2 = interval2 - interval1 - 1;		/* reduce interval2 to start at zero */
	interval1 = interval1 - 1;					/* reduce interval1 to start at zero */

		/* find TypeRoot struct for this interval set */
	t = &(quartads[interval1][interval2][interval3]);
	x->x_chord_type = t->type;
	x->x_chord_root = members[t->rootMember];
	switch(t->rootMember) {						/* get state of inversion */
			case 0: 
				x->x_chord_inversion = 0;
				break;
			case 1: 
				x->x_chord_inversion = 2;
				break;
			case 2: 
				x->x_chord_inversion = 2;
				break;
			case 3: 
				x->x_chord_inversion = 1;
	}
	chord_draw_chord_type(x, 4);				/* output results */
}

static void chord_fatal_error(char* s1, char* s2)
{
	post("chord: error: %s : %s", s1, s2);
}

static void chord_quintad(t_chord *x)
{
	static int initialized = 0;
	static t_type_root quintads[8][8][8][8];
	register int i, j, k, l;
	register t_type_root *t;
	int members[5];
	int interval1, interval2, interval3, interval4;
	int *st;
	int maj9[5][4] = {{1,1,2,3}, {0,1,1,2}, {3,0,1,1}, {2,3,0,1}, {1,2,3,0}};
	int dom9[5][4] = {{1,1,2,2}, {1,1,1,2}, {2,1,1,1}, {2,2,1,1}, {1,2,2,1}};
	int min9[5][4] = {{1,0,3,2}, {1,1,0,3}, {2,1,1,0}, {3,2,1,1}, {0,3,2,1}};
	int had9[5][4] = {{1,0,2,3}, {1,1,0,2}, {3,1,1,0}, {2,3,1,1}, {0,2,3,1}};
	int miM9[5][4] = {{1,0,3,3}, {0,1,0,3}, {3,0,1,0}, {3,3,0,1}, {0,3,3,0}};
	int diM9[5][4] = {{1,0,2,4}, {0,1,0,2}, {4,0,1,0}, {2,4,0,1}, {0,2,4,0}};
	int M9b5[5][4] = {{1,1,1,4}, {0,1,1,1}, {4,0,1,1}, {1,4,0,1}, {1,1,4,0}};
	int D9b5[5][4] = {{1,1,1,3}, {1,1,1,1}, {3,1,1,1}, {1,3,1,1}, {1,1,3,1}};
	int mM91[5][4] = {{1,0,0,6}, {0,1,0,0}, {6,0,1,0}, {0,6,0,1}, {0,0,6,0}};
	int M7b9[5][4] = {{0,2,2,3}, {0,0,2,2}, {3,0,0,2}, {2,3,0,0}, {2,2,3,0}};
	int M5b9[5][4] = {{0,2,3,2}, {0,0,2,3}, {2,0,0,2}, {3,2,0,0}, {2,3,2,0}};
	int D7b9[5][4] = {{0,2,2,2}, {1,0,2,2}, {2,1,0,2}, {2,2,1,0}, {2,2,2,1}};
	int m7b9[5][4] = {{0,1,3,2}, {1,0,1,3}, {2,1,0,1}, {3,2,1,0}, {1,3,2,1}};
	int mb51[5][4] = {{0,1,2,0}, {4,0,1,2}, {0,4,0,1}, {2,0,4,0}, {1,2,0,4}};
	int d7b9[5][4] = {{0,1,2,3}, {1,0,1,2}, {3,1,0,1}, {2,3,1,0}, {1,2,3,1}};
	int mMb9[5][4] = {{0,1,3,3}, {0,0,1,3}, {3,0,0,1}, {3,3,0,0}, {1,3,3,0}};
	int dMb9[5][4] = {{0,1,2,4}, {0,0,1,2}, {4,0,0,1}, {2,4,0,0}, {1,2,4,0}};
	int dib9[5][4] = {{0,1,2,2}, {2,0,1,2}, {2,2,0,1}, {2,2,2,0}, {1,2,2,2}};
	int M7s9[5][4] = {{2,0,2,3}, {0,2,0,2}, {3,0,2,0}, {2,3,0,2}, {0,2,3,0}};
	int D7s9[5][4] = {{2,0,2,2}, {1,2,0,2}, {2,1,2,0}, {2,2,1,2}, {0,2,2,1}};
	int M7s1[5][4] = {{3,1,0,3}, {0,3,1,0}, {3,0,3,1}, {0,3,0,3}, {1,0,3,0}};
	int d9b3[5][4] = {{1,1,2,0}, {3,1,1,2}, {0,3,1,1}, {2,0,3,1}, {1,2,0,3}};
	int M9s3[5][4] = {{1,4,2,0}, {0,1,4,2}, {0,0,1,4}, {2,0,0,1}, {4,2,0,0}};
	int M9st[5][4] = {{1,1,5,0}, {0,1,1,5}, {0,0,1,1}, {5,0,0,1}, {1,5,0,0}};
	int s9s1[5][4] = {{2,0,1,0}, {4,2,0,1}, {0,4,2,0}, {1,0,4,2}, {0,1,0,4}};
	int h7b1[5][4] = {{2,0,1,3}, {1,2,0,1}, {3,1,2,0}, {1,3,1,2}, {0,1,3,1}};
	int M711[5][4] = {{3,0,1,3}, {0,3,0,1}, {3,0,3,0}, {1,3,0,3}, {0,1,3,0}};
	int M115[5][4] = {{1,1,0,5}, {0,1,1,0}, {5,0,1,1}, {0,5,0,1}, {1,0,5,0}};
	int d711[5][4] = {{3,0,1,2}, {1,3,0,1}, {2,1,3,0}, {1,2,1,3}, {0,1,2,1}};
	int d712[5][4] = {{1,1,0,1}, {4,1,1,0}, {1,4,1,1}, {0,1,4,1}, {1,0,1,4}};
	int d713[5][4] = {{1,1,0,4}, {1,1,1,0}, {4,1,1,1}, {0,4,1,1}, {1,0,4,1}};
	int m711[5][4] = {{2,1,1,2}, {1,2,1,1}, {2,1,2,1}, {1,2,1,2}, {1,1,2,1}};
	int m712[5][4] = {{1,0,1,1}, {4,1,0,1}, {1,4,1,0}, {1,1,4,1}, {0,1,1,4}};
	int di11[5][4] = {{1,0,1,0}, {5,1,0,1}, {0,5,1,0}, {1,0,5,1}, {0,1,0,5}};
	int mM11[5][4] = {{2,1,1,3}, {0,2,1,1}, {3,0,2,1}, {1,3,0,2}, {1,1,3,0}};
	int dM11[5][4] = {{2,1,0,4}, {0,2,1,0}, {4,0,2,1}, {0,4,0,2}, {1,0,4,0}};
	int Meb5[5][4] = {{3,0,0,4}, {0,3,0,0}, {4,0,3,0}, {0,4,0,3}, {0,0,4,0}};
	int Mes5[5][4] = {{3,0,2,2}, {0,3,0,2}, {2,0,3,0}, {2,2,0,3}, {0,2,2,0}};
	int Meb9[5][4] = {{0,2,0,5}, {0,0,2,0}, {5,0,0,2}, {0,5,0,0}, {2,0,5,0}};
	int Mes9[5][4] = {{2,0,0,5}, {0,2,0,0}, {5,0,2,0}, {0,5,0,2}, {0,0,5,0}};
	int Deb5[5][4] = {{3,0,0,3}, {1,3,0,0}, {3,1,3,0}, {0,3,1,3}, {0,0,3,1}};
	int Mes3[5][4] = {{3,0,4,0}, {0,3,0,4}, {0,0,3,0}, {4,0,0,3}, {0,4,0,0}};
	int Deb9[5][4] = {{0,2,0,4}, {1,0,2,0}, {4,1,0,2}, {0,4,1,0}, {2,0,4,1}};
	int De91[5][4] = {{0,2,0,1}, {4,0,2,0}, {1,4,0,2}, {0,1,4,0}, {2,0,1,4}};
	int Des9[5][4] = {{2,0,0,4}, {1,2,0,0}, {4,1,2,0}, {0,4,1,2}, {0,0,4,1}};
	int Ds11[5][4] = {{3,1,0,2}, {1,3,1,0}, {2,1,3,1}, {0,2,1,3}, {1,0,2,1}};
	int m7s1[5][4] = {{2,2,0,2}, {1,2,2,0}, {2,1,2,2}, {0,2,1,2}, {2,0,2,1}};
	int D3s1[5][4] = {{5,0,1,0}, {1,5,0,1}, {0,1,5,0}, {1,0,1,5}, {0,1,0,1}};
	int Mb9s[5][4] = {{0,2,5,0}, {0,0,2,5}, {0,0,0,2}, {5,0,0,0}, {2,5,0,0}};
	int D7b3[5][4] = {{3,2,0,1}, {1,3,2,0}, {1,1,3,2}, {0,1,1,3}, {2,0,1,1}};

	if (!initialized) {
		for (i=0; i<8; i++)
			for (j=0; j<8; j++)
				for (k=0; k<8; k++)
					for (l=0; l<8; l++) {
						quintads[i][j][k][l].type		= kNone;
						quintads[i][j][k][l].rootMember = kXX;
					}


		// major ninths
		for (i=0; i<5; i++) {
			st = maj9[i];
			t  = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			t->type		  = kMaj9;
			t->rootMember = i;
		}

		// dominant ninths
		for (i=0; i<5; i++) {
			st = dom9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "dom9");
			t->type		  = kDom9;
			t->rootMember = i;
		}

		// minor ninths
		for (i=0; i<5; i++) {
			st = min9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "min9");
			t->type		  = kMin9;
			t->rootMember = i;
		}

		// half diminished ninths
		for (i=0; i<5; i++) {
			st = had9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "had9");
			t->type		  = kHalfDim9;
			t->rootMember = i;
		}

		// minor/major ninths
		for (i=0; i<5; i++) {
			st = miM9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "miM9");
			t->type		  = kMinMaj9;
			t->rootMember = i;
		}

		// diminished/major ninths
		for (i=0; i<5; i++) {
			st = diM9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "diM9");
			t->type		  = kDimMaj9;
			t->rootMember = i;
		}

		// major ninth flat 5
		for (i=0; i<5; i++) {
			st = M9b5[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M9b5");
			t->type		  = kMaj9b5;
			t->rootMember = i;
		}

		// dominant ninth flat 5
		for (i=0; i<5; i++) {
			st = D9b5[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D9b5");
			t->type		  = kDom9b5;
			t->rootMember = i;
		}

		// minor/major ninth flat 11
		for (i=0; i<5; i++) {
			st = mM91[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "mM91");
			t->type		  = kmM9b11;
			t->rootMember = i;
		}

		// major seventh flat nine
		for (i=0; i<5; i++) {
			st = M7b9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M7b9");
			t->type		  = kMaj7b9;
			t->rootMember = i;
		}

		// major seventh sharp five flat nine
		for (i=0; i<5; i++) {
			st = M5b9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M5b9");
			t->type		  = kMaj7s5b9;
			t->rootMember = i;
		}

		// dominant seventh flat nine
		for (i=0; i<5; i++) {
			st = D7b9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D7b9");
			t->type		  = kDom7b9;
			t->rootMember = i;
		}

		// minor seventh flat nine
		for (i=0; i<5; i++) {
			t = &(quintads[m7b9[i][0]][m7b9[i][1]][m7b9[i][2]][m7b9[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "m7b9");
			t->type		  = kMin7b9;
			t->rootMember = i;
		}

		// minor flat nine sharp eleventh
		for (i=0; i<5; i++) {
			st = mb51[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "mb51");
			t->type		  = kMinb9s11;
			t->rootMember = i;
		}

		// half diminished seventh flat nine
		for (i=0; i<5; i++) {
			st = d7b9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "d7b9");
			t->type		  = kHalfDimb9;
			t->rootMember = i;
		}

		// minor/major  seventh flat nine
		for (i=0; i<5; i++) {
			st = mMb9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "mMb9");
			t->type		  = kMinMajb9;
			t->rootMember = i;
		}

		// diminished major seventh flat nine
		for (i=0; i<5; i++) {
			st = dMb9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "dMb9");
			t->type		  = kDimMajb9;
			t->rootMember = i;
		}

		// diminished seventh flat nine
		for (i=0; i<5; i++) {
			t = &(quintads[dib9[i][0]][dib9[i][1]][dib9[i][2]][dib9[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "dib9");
			t->type		  = kDim7b9;
			t->rootMember = i;
		}

		// major seventh sharp nine
		for (i=0; i<5; i++) {
			t = &(quintads[M7s9[i][0]][M7s9[i][1]][M7s9[i][2]][M7s9[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M7s9");
			t->type		  = kMaj7s9;
			t->rootMember = i;
		}

		// dominant seventh sharp nine
		for (i=0; i<5; i++) {
			t = &(quintads[D7s9[i][0]][D7s9[i][1]][D7s9[i][2]][D7s9[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D7s9");
			t->type		  = kDom7s9;
			t->rootMember = i;
		}

		// major seventh sharp eleventh
		for (i=0; i<5; i++) {
			t = &(quintads[M7s1[i][0]][M7s1[i][1]][M7s1[i][2]][M7s1[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M7s1");
			t->type		  = kMaj7s11;
			t->rootMember = i;
		}

		// dominant ninth flat thirteenth
		for (i=0; i<5; i++) {
			st = d9b3[i];
			t  = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "d9b3");
			t->type		  = kDom9b13;
			t->rootMember = i;
		}

		// major ninth sharp thirteenth
		for (i=0; i<5; i++) {
			st = M9s3[i];
			t  = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M9s3");
			t->type		  = kMaj9s13;
			t->rootMember = i;
		}

		// major ninth sharp thirteenth
		for (i=0; i<5; i++) {
			t = &(quintads[M9st[i][0]][M9st[i][1]][M9st[i][2]][M9st[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M9st");
			t->type		  = kMaj9s13;
			t->rootMember = i;
		}

		// major chord sharp ninth sharp eleventh
		for (i=0; i<5; i++) {
			st = s9s1[i];
			t  = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "s9s1");
			t->type		  = kMs9s11;
			t->rootMember = i;
		}

		// half diminished seven flat 11
		for (i=0; i<5; i++) {
			st = h7b1[i];
			t  = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "h7b1");
			t->type		  = kHDimb11;
			t->rootMember = i;
		}

		// major eleventh
		for (i=0; i<5; i++) {
			t = &(quintads[M711[i][0]][M711[i][1]][M711[i][2]][M711[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M711");
			t->type		  = kMaj11;
			t->rootMember = i;
		}

		// major eleventh
		for (i=0; i<5; i++) {
			t = &(quintads[M115[i][0]][M115[i][1]][M115[i][2]][M115[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M711");
			t->type		  = kMaj11;
			t->rootMember = i;
		}

		// dominant eleventh
		for (i=0; i<5; i++) {
			t = &(quintads[d711[i][0]][d711[i][1]][d711[i][2]][d711[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "d711");
			t->type		  = kDom11;
			t->rootMember = i;
		}

		// dominant eleventh
		for (i=0; i<5; i++) {
			t = &(quintads[d712[i][0]][d712[i][1]][d712[i][2]][d712[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "d712");
			t->type		  = kDom11;
			t->rootMember = i;
		}

		// dominant eleventh
		for (i=0; i<5; i++) {
			st = d713[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "d713");
			t->type		  = kDom11;
			t->rootMember = i;
		}

		// minor eleventh
		for (i=0; i<5; i++) {
			t = &(quintads[m711[i][0]][m711[i][1]][m711[i][2]][m711[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "m711");
			t->type		  = kMin11;
			t->rootMember = i;
		}

		// minor eleventh
		for (i=0; i<5; i++) {
			t = &(quintads[m712[i][0]][m712[i][1]][m712[i][2]][m712[i][3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "m712");
			t->type		  = kMin11;
			t->rootMember = i;
		}

		// diminished eleventh
		for (i=0; i<5; i++) {
			st = di11[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "di11");
			t->type		  = kDim11;
			t->rootMember = i;
		}

		// minor/major eleventh
		for (i=0; i<5; i++) {
			st = mM11[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "mM11");
			t->type		  = kMinMaj11;
			t->rootMember = i;
		}

		// diminished major eleventh
		for (i=0; i<5; i++) {
			st = dM11[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "dM11");
			t->type		  = kDimMaj11;
			t->rootMember = i;
		}

		// major eleventh flat fifth
		for (i=0; i<5; i++) {
			st = Meb5[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Meb5");
			t->type		  = kMaj11b5;
			t->rootMember = i;
		}

		// major eleventh sharp fifth
		for (i=0; i<5; i++) {
			st = Mes5[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Mes5");
			t->type		  = kMaj11s5;
			t->rootMember = i;
		}

		// major eleventh flat ninth
		for (i=0; i<5; i++) {
			st = Meb9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Meb9");
			t->type		  = kMaj11b9;
			t->rootMember = i;
		}

		// major eleventh sharp ninth
		for (i=0; i<5; i++) {
			st = Mes9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Mes9");
			t->type		  = kMaj11s9;
			t->rootMember = i;
		}

		// major eleventh sharp thirteenth
		for (i=0; i<5; i++) {
			st = Mes3[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Mes3");
			t->type		  = kMaj11s13;
			t->rootMember = i;
		}

		// dominant eleventh flat fifth
		for (i=0; i<5; i++) {
			st = Deb5[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Deb5");
			t->type		  = kDom11b5;
			t->rootMember = i;
		}

		// dominant eleventh flat ninth
		for (i=0; i<5; i++) {
			st = Deb9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Deb9");
			t->type		  = kDom11b9;
			t->rootMember = i;
		}

		// dominant eleventh flat ninth
		for (i=0; i<5; i++) {
			st = De91[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "De91");
			t->type		  = kDom11b9;
			t->rootMember = i;
		}

		// dominant eleventh sharp ninth
		for (i=0; i<5; i++) {
			st = Des9[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Des9");
			t->type		  = kDom11s9;
			t->rootMember = i;
		}

		// dominant seventh sharp eleventh
		for (i=0; i<5; i++) {
			st = Ds11[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Ds11");
			t->type		  = kDom7s11;
			t->rootMember = i;
		}

		// minor seventh sharp eleventh
		for (i=0; i<5; i++) {
			st = m7s1[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "m7s1");
			t->type		  = kMin7s11;
			t->rootMember = i;
		}

		// dominant thirteenth sharp eleventh
		for (i=0; i<5; i++) {
			st = D3s1[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D3s1");
			t->type		  = kDom13s11;
			t->rootMember = i;
		}

		// major seventh flat ninth sharp thirteenth
		for (i=0; i<5; i++) {
			st = Mb9s[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "Mb9s");
			t->type		  = kM7b9s13;
			t->rootMember = i;
		}

		// dominant seventh flat thirteenth
		for (i=0; i<5; i++) {
			st = D7b3[i];
			t = &(quintads[st[0]][st[1]][st[2]][st[3]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D7b3");
			t->type		  = kDom7b13;
			t->rootMember = i;
		}

		initialized = 1;
		return;
	}

	j = 0;
	for (i=0; i<12; i++)
		if (x->x_pc[i]) members[j++] = i;		/* load members array with chord pitch classes */
	interval1 = members[1] - members[0];		/* calculate interval between first two members */
	interval2 = members[2] - members[0];		/* calculate interval between first and third */
	interval3 = members[3] - members[0];		/* calculate interval between first and third */
	interval4 = members[4] - members[0];		/* calculate interval between first and fourth */
	interval4 = interval4 - interval3 - 1;		/* reduce interval4 to start at zero */
	interval3 = interval3 - interval2 - 1;		/* reduce interval3 to start at zero */
	interval2 = interval2 - interval1 - 1;		/* reduce interval2 to start at zero */
	interval1 = interval1 - 1;					/* reduce interval1 to start at zero */

	// find TypeRoot struct for this interval set
	t = &(quintads[interval1][interval2][interval3][interval4]);
	if (t->rootMember != kXX)
	{
		x->x_chord_type = t->type;
		x->x_chord_root = members[t->rootMember];
		switch(t->rootMember) {						/* get state of inversion */
			case 0: 
				x->x_chord_inversion = 0;
				break;
			case 1: 
				x->x_chord_inversion = 2;
				break;
			case 2: 
				x->x_chord_inversion = 2;
				break;
			case 3: 
				x->x_chord_inversion = 2;
				break;
			case 4: 
				x->x_chord_inversion = 1;
		}
		chord_draw_chord_type(x, 5);				/* output result */
	} else
		chord_kick_out_member(x, 5, members);
}

static void chord_sextad(t_chord *x)
{
	static int initialized = 0;
	static t_type_root sextads[7][7][7][7][7];
	register int i, j, k, l, m;
	register t_type_root *t;
	register int* st;
	int members[6];
	int interval1, interval2, interval3, interval4, interval5;

	int D9b3[6][5] =
		{{1,1,2,0,1}, {1,1,1,2,0}, {1,1,1,1,2}, {0,1,1,1,1}, {2,0,1,1,1}, {1,2,0,1,1}};
	int m9s1[6][5] =
		{{1,0,2,0,2}, {1,1,0,2,0}, {2,1,1,0,2}, {0,2,1,1,0}, {2,0,2,1,1}, {0,2,0,2,1}};
	int M711[6][5] =
		{{1,1,0,1,3}, {0,1,1,0,1}, {3,0,1,1,0}, {1,3,0,1,1}, {0,1,3,0,1}, {1,0,1,3,0}};
	int D711[6][5] =
		{{1,1,0,1,2}, {1,1,1,0,1}, {2,1,1,1,0}, {1,2,1,1,1}, {0,1,2,1,1}, {1,0,1,2,1}};
	int hd11[6][5] =
		{{1,0,1,0,3}, {1,1,0,1,0}, {3,1,1,0,1}, {0,3,1,1,0}, {1,0,3,1,1}, {0,1,0,3,1}};
	int M1b5[6][5] =
		{{1,1,0,0,4}, {0,1,1,0,0}, {4,0,1,1,0}, {0,4,0,1,1}, {0,0,4,0,1}, {1,0,0,4,0}};
	int M159[6][5] =
		{{0,2,0,0,4}, {0,0,2,0,0}, {4,0,0,2,0}, {0,4,0,0,2}, {0,0,4,0,0}, {2,0,0,4,0}};
	int M1s3[6][5] =
		{{1,1,0,4,0}, {0,1,1,0,4}, {0,0,1,1,0}, {4,0,0,1,1}, {0,4,0,0,1}, {1,0,4,0,0}};
	int hd19[6][5] =
		{{0,1,1,0,3}, {1,0,1,1,0}, {3,1,0,1,1}, {0,3,1,0,1}, {1,0,3,1,0}, {1,1,0,3,1}};
	int M1b3[6][5] =
		{{3,0,1,0,2}, {0,3,0,1,0}, {2,0,3,0,1}, {0,2,0,3,0}, {1,0,2,0,3}, {0,1,0,2,0}};
	int D1b5[6][5] =
		{{1,1,0,0,3}, {1,1,1,0,0}, {3,1,1,1,0}, {0,3,1,1,1}, {0,0,3,1,1}, {1,0,0,3,1}};
	int D1s9[6][5] =
		{{2,0,0,1,2}, {1,2,0,0,1}, {2,1,2,0,0}, {1,2,1,2,0}, {0,1,2,1,2}, {0,0,1,2,1}};
	int m791[6][5] =
		{{0,1,2,0,2}, {1,0,1,2,0}, {2,1,0,1,2}, {0,2,1,0,1}, {2,0,2,1,0}, {1,2,0,2,1}};
	int d7s1[6][5] =
		{{1,1,1,0,2}, {1,1,1,1,0}, {2,1,1,1,1}, {0,2,1,1,1}, {1,0,2,1,1}, {1,1,0,2,1}};
	int d3s1[6][5] =
		{{3,1,0,1,0}, {1,3,1,0,1}, {0,1,3,1,0}, {1,0,1,3,1}, {0,1,0,1,3}, {1,0,1,0,1}};


	if (!initialized) {
		for (i=0; i<7; i++)
			for (j=0; j<7; j++)
				for (k=0; k<7; k++)
					for (l=0; l<7; l++) 
						for (m=0; m<7; m++) {
							sextads[i][j][k][l][m].type		= kNone;
							sextads[i][j][k][l][m].rootMember = kXX;
						}

		// dominant ninth flat thirteen
		for (i=0; i<6; i++) {
			st = D9b3[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D9b3");
			t->type		  = kDom9b13;
			t->rootMember = i;
		}

		// minor ninth sharp eleventh
		for (i=0; i<6; i++) {
			st = m9s1[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "m9s1");
			t->type		  = kMin9s11;
			t->rootMember = i;
		}

		// major eleventh
		for (i=0; i<6; i++) {
			st = M711[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M711");
			t->type		  = kMaj11;
			t->rootMember = i;
		}

		// dominant eleventh
		for (i=0; i<6; i++) {
			st = D711[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D711");
			t->type		  = kDom11;
			t->rootMember = i;
		}

		// half diminished eleventh
		for (i=0; i<6; i++) {
			st = hd11[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "hd11");
			t->type		  = kHalfDim11;
			t->rootMember = i;
		}

		// major eleventh flat 5
		for (i=0; i<6; i++) {
			st = M1b5[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M1b5");
			t->type		  = kMaj11b5;
			t->rootMember = i;
		}

		// major eleventh flat 5 flat 9
		for (i=0; i<6; i++) {
			st = M159[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M159");
			t->type		  = kM11b5b9;
			t->rootMember = i;
		}

		// major eleventh sharp 13
		for (i=0; i<6; i++) {
			st = M1s3[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M1s3");
			t->type		  = kMaj11s13;
			t->rootMember = i;
		}

		// half diminished eleventh flat 9
		for (i=0; i<6; i++) {
			st = hd19[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "hd19");
			t->type		  = kHalfDim11b9;
			t->rootMember = i;
		}

		// major eleventh flat 13
		for (i=0; i<6; i++) {
			st = M1b3[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "M1b3");
			t->type		  = kMaj11b13;
			t->rootMember = i;
		}

		// dominant eleventh flat five
		for (i=0; i<6; i++) {
			st = D1b5[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D1b5");
			t->type		  = kDom11b5;
			t->rootMember = i;
		}

		// dominant eleventh sharp nine
		for (i=0; i<6; i++) {
			st = D1s9[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "D1s9");
			t->type		  = kDom11s9;
			t->rootMember = i;
		}

		// minor seventh flat 9 sharp 11
		for (i=0; i<6; i++) {
			st = m791[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "m791");
			t->type		  = kMinb9s11;
			t->rootMember = i;
		}

		// dominant seventh sharp 11
		for (i=0; i<6; i++) {
			st = d7s1[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "d7s1");
			t->type		  = kDom7s11;
			t->rootMember = i;
		}

		// dominant thirteenth sharp 11
		for (i=0; i<6; i++) {
			st = d3s1[i];
			t = &(sextads[st[0]][st[1]][st[2]][st[3]][st[4]]);
			if (t->type != kNone) chord_fatal_error("redefining chord", "d3s1");
			t->type		  = kDom13s11;
			t->rootMember = i;
		}

		initialized = 1;
		return;
	}

	j = 0;
	for (i=0; i<12; i++)
		if (x->x_pc[i]) members[j++] = i;		// load members array with chord pitch classes
	interval1 = members[1] - members[0];		// calculate interval between first two members
	interval2 = members[2] - members[0];		// calculate interval between first and third
	interval3 = members[3] - members[0];		// calculate interval between first and third
	interval4 = members[4] - members[0];		// calculate interval between first and fourth
	interval5 = members[5] - members[0];		// calculate interval between first and fifth
	interval5 = interval5 - interval4 - 1;		// reduce interval5 to start at zero
	interval4 = interval4 - interval3 - 1;		// reduce interval4 to start at zero
	interval3 = interval3 - interval2 - 1;		// reduce interval3 to start at zero
	interval2 = interval2 - interval1 - 1;		// reduce interval2 to start at zero
	interval1 = interval1 - 1;					// reduce interval1 to start at zero

	// find TypeRoot struct for this interval set
	t = &(sextads[interval1][interval2][interval3][interval4][interval5]);
	if (t->rootMember != kXX) {
		x->x_chord_type = t->type;
		x->x_chord_root = members[t->rootMember];
		switch(t->rootMember) {						/* get state of inversion */
			case 0: 
				x->x_chord_inversion = 0;
				break;
			case 1: 
				x->x_chord_inversion = 2;
				break;
			case 2: 
				x->x_chord_inversion = 2;
				break;
			case 3: 
				x->x_chord_inversion = 2;
				break;
			case 4: 
				x->x_chord_inversion = 2;
				break;
			case 5: x->x_chord_inversion = 1;
		}
		chord_draw_chord_type(x, 6);						// output onto the screen
	} else
		chord_kick_out_member(x, 6, members);
}

static int chord_accidental(t_int pc)
{
	switch (pc) {
		case  0:
		case  2:
		case  4:
		case  5:
		case  7:
		case  9:
		case 11:	return 0;
		case  1:
		case  3:
		case  6:
		case  8:
		case 10:	
		default:	return 1;
	}
}

static int chord_name_third(t_chord *x, char* chord, int c, int rootName)
{
	int third = (x->x_chord_root+4)%12;		// look for major third
	if (x->x_pc[third]) {					// if one is there
		x->x_pc[third] = 0;					// erase from pcs array
		chord[c++] = name_class[(rootName+2)%7];
		if (chord_accidental(third))			// if it has an chord_accidental
			// make it a flat if the root also has an chord_accidental
			if (chord_accidental(x->x_chord_root)) chord[c++] = 'b';
			// otherwise make it a sharp
			else					   chord[c++] = '#';
		chord[c++] = ' ';
		return c;						// return if major third found
	}

	third = (x->x_chord_root+3)%12;			// no major, look for minor third
	if (x->x_pc[third]) {					// if one is there
		x->x_pc[third] = 0;					// erase from pcs array
		chord[c++] = name_class[(rootName+2)%7];
		if (chord_accidental(third))			// if it has an chord_accidental
			chord[c++] = 'b'; else		// make it a flat
		if (chord_accidental(x->x_chord_root)) {	// if the root has an chord_accidental
			chord[c++] = 'b';			// make the third a flat
			if (chord[0] == 'G')		// if the root is Gb
				chord[c++] = 'b';		// this must be Bbb
		}
		chord[c++] = ' ';
		return c;
	}

	return c;							// if we get here there was no third
}

static int chord_name_fifth(t_chord *x, char* chord, int c, int rootName)
{
	int fifth = (x->x_chord_root+7)%12;
	if (x->x_pc[fifth]) {
		x->x_pc[fifth] = 0;
		chord[c++] = name_class[(rootName+4)%7];
		if (chord_accidental(fifth)) {
			if (chord_accidental(x->x_chord_root)) chord[c++] = 'b';
			else					   chord[c++] = '#';
		}
		chord[c++] = ' ';
		return c;
	}

	fifth = (x->x_chord_root+6)%12;
	if (x->x_pc[fifth]) {
		x->x_pc[fifth] = 0;
		chord[c++] = name_class[(rootName+4)%7];
		if (chord[0] != 'B')	   chord[c++] = 'b';
		if (chord_accidental(x->x_chord_root)) chord[c++] = 'b';
		chord[c++] = ' ';
		return c;
	}
	
	fifth = (x->x_chord_root+8)%12;
	if (x->x_pc[fifth]) {
		x->x_pc[fifth] = 0;
		chord[c++] = name_class[(rootName+4)%7];
		if (chord_accidental(fifth)) chord[c++] = '#'; else
		if (!chord_accidental(x->x_chord_root)) {
			chord[c++] = '#';
			if (chord[0] == 'B')
				chord[c++] = '#';
		}
		chord[c++] = ' ';
		return c;
	}
	
	return c;
}

static int chord_name_seventh(t_chord *x, char* chord, int c, int rootName)
{
	int seventh = (x->x_chord_root+11)%12;
	if (x->x_pc[seventh]) {
		x->x_pc[seventh] = 0;
		chord[c++] = name_class[(rootName+6)%7];
		if (chord_accidental(seventh)) chord[c++] = '#';
		chord[c++] = ' ';
		return c;
	}
	seventh = (x->x_chord_root+10)%12;
	if (x->x_pc[seventh]) {
		x->x_pc[seventh] = 0;
		chord[c++]   = name_class[(rootName+6)%7];
		if (chord_accidental(seventh) || chord_accidental(x->x_chord_root))
			chord[c++] = 'b';
		chord[c++]   = ' ';
		return c;
	}
	seventh = (x->x_chord_root+9)%12;
	if (x->x_pc[seventh]) {
		x->x_pc[seventh] = 0;
		chord[c++] = name_class[(rootName+6)%7];
		chord[c++] = 'b';
		if (chord_accidental(x->x_chord_root))		chord[c++] = 'b'; else
		if (chord_accidental((seventh+1)%12)) chord[c++] = 'b';
		chord[c++] = ' ';
		return c;
	}
	return c;
}

static int chord_name_ninth(t_chord *x, char* chord, int c, int rootName)
{
	int ninth = (x->x_chord_root+2)%12;
	if (x->x_pc[ninth]) {
		x->x_pc[ninth] = 0;
		chord[c++] = name_class[(rootName+1)%7];
		if (chord_accidental(ninth)) {
			if (chord_accidental(x->x_chord_root)) chord[c++] = 'b';
			else					   chord[c++] = '#';
		}
		chord[c++] = ' ';
		return c;
	}

	ninth = (x->x_chord_root+1)%12;
	if (x->x_pc[ninth]) {
		x->x_pc[ninth] = 0;
		chord[c++] = name_class[(rootName+1)%7];
		if (chord_accidental(ninth)) chord[c++] = 'b';
		else {
			if (chord_accidental(x->x_chord_root)) {
				chord[c++] = 'b';
				if ((x->x_chord_root == 1) || (x->x_chord_root == 6) || (x->x_chord_root == 8))
					chord[c++] = 'b';
			}
		}
		chord[c++] = ' ';
		return c;
	}

	ninth = (x->x_chord_root+3)%12;
	if (x->x_pc[ninth]) {
		x->x_pc[ninth] = 0;
		chord[c++] = name_class[(rootName+1)%7];
		if (chord_accidental(ninth)) chord[c++] = '#'; else
		if (!chord_accidental(x->x_chord_root)) {
			chord[c++] = '#';
			if (chord_accidental((x->x_chord_root+2)%12))
				chord[c++] = '#';
		}
		chord[c++] = ' ';
		return c;
	}

	return c;
}

static int chord_name_eleventh(t_chord *x, char* chord, int c, int rootName)
{
	int eleventh = (x->x_chord_root+5)%12;
	if (x->x_pc[eleventh]) {
		x->x_pc[eleventh] = 0;
		chord[c++] = name_class[(rootName+3)%7];
		if (chord_accidental(eleventh))  chord[c++] = 'b'; else
		if (chord_accidental(x->x_chord_root)) chord[c++] = 'b';
		chord[c++] = ' ';
		return c;
	}
	
	eleventh = (x->x_chord_root+6)%12;
	if (x->x_pc[eleventh]) {
		x->x_pc[eleventh] = 0;
		chord[c++] = name_class[(rootName+3)%7];
		if (chord_accidental(eleventh))  chord[c++] = '#'; else
		if ((!chord_accidental(x->x_chord_root)) && (x->x_chord_root == 11))
			chord[c++] = '#';
		chord[c++] = ' ';
		return c;
	}

	return c;
}

static int chord_name_thirteenth(t_chord *x, char* chord, int c, int rootName)
{
	int thirteenth = (x->x_chord_root+9)%12;
	if (x->x_pc[thirteenth]) {
		x->x_pc[thirteenth] = 0;
		chord[c++] = name_class[(rootName+5)%7];
		if (chord_accidental(thirteenth))
			if (chord_accidental(x->x_chord_root))
				chord[c++] = 'b'; else
				chord[c++] = '#';
		chord[c++] = ' ';
		return c;
	}
	
	thirteenth = (x->x_chord_root+10)%12;
	if (x->x_pc[thirteenth]) {
		x->x_pc[thirteenth] = 0;
		chord[c++] = name_class[(rootName+5)%7];
		if (chord_accidental(thirteenth)) chord[c++] = '#'; else
		if (!chord_accidental(x->x_chord_root)) {
			chord[c++] = '#';
			if (chord_accidental((x->x_chord_root+9)%12))
				chord[c++] = '#';
		}
		chord[c++] = ' ';
		return c;
	}

	thirteenth = (x->x_chord_root+8)%12;
	if (x->x_pc[thirteenth]) {
		x->x_pc[thirteenth] = 0;
		chord[c++] = name_class[(rootName+5)%7];
		if (chord_accidental(thirteenth)) chord[c++] = 'b'; else
		if (chord_accidental(x->x_chord_root)) {
			chord[c++] = 'b';
			if (chord_accidental(x->x_chord_root+9)%12)
				chord[c++] = 'b';
		}
		chord[c++] = ' ';
		return c;
	}

	return c;
}



static void chord_spell_chord(t_chord *x, char *chord, t_int num_pcs)
{
	int rootName = 0;			// keep index of root name class
	int c     = 0;				// pointer to current character
	int named = 0;				// how many members have been named
	int mark;
	int i;

	// use chordRoot to set rootName index and store characters for name
	switch (x->x_chord_root)
	{
		case 0:		chord[c++] = name_class[rootName=0];	break;
		case 1:		chord[c++] = name_class[rootName=1];
				chord[c++] = 'b';			break;
		case 2:		chord[c++] = name_class[rootName=1];	break;
		case 3:		chord[c++] = name_class[rootName=2];
				chord[c++] = 'b';			break;
		case 4:		chord[c++] = name_class[rootName=2];	break;
		case 5:		chord[c++] = name_class[rootName=3];	break;
		case 6:		chord[c++] = name_class[rootName=4];
				chord[c++] = 'b';			break;
		case 7:		chord[c++] = name_class[rootName=4];	break;
		case 8:		chord[c++] = name_class[rootName=5];
				chord[c++] = 'b';			break;
		case 9:		chord[c++] = name_class[rootName=5];	break;
		case 10:	chord[c++] = name_class[rootName=6];
				chord[c++] = 'b';			break;
		case 11:	chord[c++] = name_class[rootName=6];	break;
		default:						break;
	}
	x->x_pc[x->x_chord_root] = 0;					/* set this member to zero */

	chord[c++] = ' ';			// insert space
	if (++named == num_pcs) {	// if everything is named
		chord[c] = '\0';		// terminate the string
		return;					// and return
	}

	mark = c;				// use mark to see if new names are added
	for (i=0; i<6; i++) {
		// advance search by thirds
		switch (i) {
			case 0:	mark = chord_name_third	 (x, chord, c, rootName); break;
			case 1:	mark = chord_name_fifth	 (x, chord, c, rootName); break;
			case 2:	mark = chord_name_seventh	 (x, chord, c, rootName); break;
			case 3:	mark = chord_name_ninth	 (x, chord, c, rootName); break;
			case 4:	mark = chord_name_eleventh	 (x, chord, c, rootName); break;
			case 5:	mark = chord_name_thirteenth(x, chord, c, rootName); break;
		}
		if (mark != c) {		// if new name is added
			++named;			// increment count of named members
			c = mark;			// update character pointer
		}
		if (named == num_pcs) {	// if everything is named
			chord[c] = '\0';	// terminate the string
			return;				// and return
		}
	}

	chord[c] = '\0';
}


static void chord_draw_chord_type(t_chord *x, t_int num_pcs)
{
	char   chord[255];				/* output string */
	int i, j;

		/* get members of chord */
	j = 0;
	for(i = 0; i < 12; i++)
	{
		if(x->x_pc[i])
		{
			SETFLOAT(x->x_chordlist+j, x->x_abs_pc[i]);
			j++;
		}
	}

	if (x->x_chord_type != kNone)
	{
		chord_spell_chord(x, chord, num_pcs);	/* spell chord members */
	}
	else
	{
		post("going...");
		chord[0] = '\0';
		for(i = 0; i < 12; i++)
			if (x->x_pc[i]) 
				strcat(chord, pitch_class[i]);	/* output single notes */
		post("did it");
	}

	strcat(chord, ": ");
	strcat(chord, pitch_class[x->x_chord_root]);
	
		/* append name of chord type */
	switch (x->x_chord_type) {
		case kUnison:	strcat(chord, "unison"); 			  break;
		case kMaj:		strcat(chord, "major"); 			  break;
		case kMin:		strcat(chord, "minor"); 			  break;
		case kDim:		strcat(chord, "diminished"); 		  break;
		case kAug:		strcat(chord, "augmented"); 		  break;

		case kMaj7:		strcat(chord, "major 7th"); 		  break;
		case kDom7:		strcat(chord, "dominant 7th"); 		  break;
		case kMin7: 	strcat(chord, "minor 7th"); 		  break;
		case kHalfDim7:	strcat(chord, "half diminished 7th"); break;
		case kDim7:		strcat(chord, "diminished 7th");	  break;
		case kMinMaj7:	strcat(chord, "minor/major 7th");	  break;

		case kMaj7s5:	strcat(chord, "major 7th #5");		  break;
		case kMaj7b5:	strcat(chord, "major 7th b5");		  break;
		case kDom7s5:	strcat(chord, "dominant 7th #5"); 	  break;
		case kDom7b5:	strcat(chord, "dominant 7th b5"); 	  break;
		case kDomb9:	strcat(chord, "dominant b9");		  break;

		case kMaj9:		strcat(chord, "major 9th");			  break;
		case kDom9:		strcat(chord, "dominant 9th");		  break;
		case kMin9:		strcat(chord, "minor 9th");			  break;
		case kHalfDim9:	strcat(chord, "half diminished 9th"); break;
		case kMinMaj9:	strcat(chord, "minor major 9th");	  break;
		case kDimMaj9:	strcat(chord, "diminished major 9th");break;
		case kMaj9b5:	strcat(chord, "major 9th b5");		  break;
		case kDom9b5:	strcat(chord, "dominant 9th b5");	  break;
		case kDom9b13:	strcat(chord, "dominant 9th b13");	  break;
		case kMin9s11:	strcat(chord, "minor 9th #11");		  break;
		case kmM9b11:	strcat(chord, "minor/maj 9th b11");	  break;

		case kMaj7b9:	strcat(chord, "major 7th b9");		  break;
		case kMaj7s5b9:	strcat(chord, "major 7th #5 b9");	  break;
		case kDom7b9:	strcat(chord, "dominant 7th b9");	  break;
		case kMin7b9:	strcat(chord, "minor 7th b9");		  break;
		case kMinb9s11:	strcat(chord, "minor b9 #11");		  break;
		case kHalfDimb9:strcat(chord, "half diminished b9");  break;
		case kDim7b9:	strcat(chord, "diminished b9");		  break;
		case kMinMajb9: strcat(chord, "minor/major b9");	  break;
		case kDimMajb9:	strcat(chord, "diminished M7 b9");	  break;

		case kMaj7s9:	strcat(chord, "major 7th #9");		  break;
		case kDom7s9:	strcat(chord, "dominant #9");		  break;
		case kMaj7s11:	strcat(chord, "major 7th #11");		  break;
		case kMaj9s13:	strcat(chord, "major 9th #13");		  break;
		case kMs9s11:	strcat(chord, "major #9 #11");		  break;
		case kHDimb11:	strcat(chord, "half diminished b11"); break;

		case kMaj11:	strcat(chord, "major 11th");		  break;
		case kDom11:	strcat(chord, "dominant 11th");		  break;
		case kMin11:	strcat(chord, "minor 11th");		  break;
		case kHalfDim11:strcat(chord, "half diminished 11th");break;
		case kDim11:	strcat(chord, "diminished 11th");	  break;
		case kMinMaj11:	strcat(chord, "minor/major 11th");	  break;
		case kDimMaj11: strcat(chord, "diminished maj 11th"); break;

		case kMaj11b5:	strcat(chord, "major 11th b5");		  break;
		case kMaj11s5:	strcat(chord, "major 11th #5");		  break;
		case kMaj11b9:	strcat(chord, "major 11th b9");		  break;
		case kMaj11s9:	strcat(chord, "major 11th #9");		  break;
		case kMaj11b13:	strcat(chord, "major 11th b13");	  break;
		case kMaj11s13:	strcat(chord, "major 11th #13");	  break;
		case kM11b5b9:	strcat(chord, "major 11th b5 b9");	  break;
		case kDom11b5:	strcat(chord, "dominant 11th b5");	  break;
		case kDom11b9:	strcat(chord, "dominant 11th b9");	  break;
		case kDom11s9:	strcat(chord, "dominant 11th #9");	  break;
		case kHalfDim11b9:strcat(chord, "half dim 11th b9");  break;
		case kDom7s11:	strcat(chord, "dominant #11");		  break;
		case kMin7s11:	strcat(chord, "minor 7th #11");		  break;

		case kDom13s11:	strcat(chord, "dominant 13th #11");	  break;
		case kM7b913:	strcat(chord, "major 7 b9 13");		  break;
		case kMaj7s13:	strcat(chord, "major 7th #13");		  break;
		case kM7b9s13:	strcat(chord, "major 7 b9 #13");	  break;
		case kDom7b13:	strcat(chord, "dominant 7th b13");	  break;
		case kChrom:	strcat(chord, "chromatic");			  break;
		case kNone:
		default:	 	strcat(chord, "unknown"); 			  break;
	}

	x->x_chord_bass = x->x_abs_pc[x->x_chord_root];	/* get MIDI note number of bass */

		/* output results */
	outlet_list(x->x_outchordnotes, NULL, j, x->x_chordlist);
	outlet_float(x->x_outchordinversion, x->x_chord_inversion);
	outlet_symbol(x->x_outchordname, gensym(chord));
	outlet_float(x->x_outchordclass, x->x_chord_root);
	outlet_float(x->x_outchordval, x->x_chord_bass);
}

static void chord_kick_out_member(t_chord *x, t_int number, t_int *members)
{
	int *distances;
	int minDistance = 1000;
	int badMember   = 0;
	int i, j, interval;

	distances = getbytes(number*sizeof(int));
	
	for (i=0; i<number; i++) {
		// initialize total distance to zero
		distances[i] = 0;
		for (j=0; j<number; j++)
			if (j != i) {
				// get absolute value of interval size
				interval = abs(members[i] - members[j]);
				// make inversions of intervals equivalent
				if (interval > 6) interval = 12 - interval;
				// add absolute interval size to total
				distances[i] += interval;
			}
		
		// if this is the smallest total distance
		if (distances[i] < minDistance) {
			// remember it
			minDistance = distances[i];
			badMember   = i;
		}
	}
	freebytes(distances, number * sizeof(int));
	x->x_pc[members[badMember]] = 0;			// cancel out most dissonant member
	chord_chord_finder(x, number-1);			// call chord finder again without it
	x->x_pc[members[badMember]] = 1;			// replace most dissonant member
}

static void chord_chord_finder(t_chord *x, t_int num_pcs)
{
	int i;
	x->x_chord_type = kNone;
	x->x_chord_root = kXX;	/* none */
	switch (num_pcs) {
		case  1:	chord_unison(x);	break;
		case  2:	chord_dyad(x);		break;
		case  3:	chord_triad(x);		break;
		case  4:	chord_quartad(x);	break;
		case  5:	chord_quintad(x);	break;
		case  6:	chord_sextad(x);	break;
		default:	x->x_chord_type = kChrom;
					for(i = 0; i < 12; i++)   // 12 was num_pcs !?
					{
						if(x->x_pc[i])
						{
							x->x_chord_root = i;
							break;
						}
					}
	}
}

static void chord_float(t_chord *x, t_floatarg f)
{
	t_int velo = x->x_velo;
	t_int allloc = 0;
	t_int num_pc = 0;	/* number of pitch classes present */
	int i, j, k, l;

	x->x_pitch = (t_int)f;

	if(x->x_pitch <= x->x_split)
	{
			/* first we need to put the note into the allocation table */
		if(velo == 0)	/* got note-off: remove from allocation table */
		{
			if(x->x_poly > 0)x->x_poly--; /* polyphony has decreased by one */
			for(i = 0; i < MAX_POLY; i++) /* search for voice allocation number */
			{
					/* search for corresponding alloc number */
				if(x->x_alloctable[i] == x->x_pitch)
				{
					x->x_alloctable[i] = -1;     /* free the alloc number */
					break;
				}
					/* couldn't find it ? */
				if(i == MAX_POLY - 1)
				{
					post("chord: no corresponding note-on found (ignored)");
					return;
				}
			}
			return;		/* no need to look for chord */
		}
		else	/* we got a note-on message */
		{
			if(x->x_poly == MAX_POLY)
			{
				post("chord: too many note-on messages (ignored)");
				return;
			}
			
			x->x_poly++;      /* number of currently playing notes has increased */
				/* assign a voice allocation number */
			for(i = 0; i < MAX_POLY; i++)
			{
					/* search for free alloc number */
				if(x->x_alloctable[i] == -1)
				{
					x->x_alloctable[i] = x->x_pitch;   /* ... and store pitch */
					break;
				}
			}
				/* copy all notes into the pitch class array */
			for(i = 0; i < 12; i++)
			{
				x->x_pc[i] = 0;						/* empty pitch class */
				x->x_abs_pc[i] = -1;				/* empty absolute values */
			}
			for(i = 0; i < MAX_POLY; i++)
			{
					/* check for presence of pitch class */
				if(x->x_alloctable[i] != -1)
				{
					if(!x->x_pc[x->x_alloctable[i]%12])	/* a new pitch class */
					{
						x->x_abs_pc[x->x_alloctable[i]%12] = x->x_alloctable[i];
					}
					else if(x->x_abs_pc[x->x_alloctable[i]%12] > x->x_alloctable[i])	/* remember lowest pitch */
					{
						x->x_abs_pc[x->x_alloctable[i]%12] = x->x_alloctable[i];
					}

					x->x_pc[x->x_alloctable[i]%12] = 1;	/* indicate presence of pc */
				}
			}
				/* count number of pitch classes */
			for(i = 0; i < 12; i++)
			{
				num_pc += x->x_pc[i];
			}
			// post("%d pitch classes", num_pc);
		}
	}

	chord_chord_finder(x, num_pc);
}

static void chord_ft1(t_chord *x, t_floatarg f)
{
	x->x_velo = (t_int)f;
}

static t_class *chord_class;

static void *chord_new(t_floatarg f)
{
	int i;
    t_chord *x = (t_chord *)pd_new(chord_class);
    inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
	x->x_outchordval = outlet_new(&x->x_ob, gensym("float"));
	x->x_outchordclass = outlet_new(&x->x_ob, gensym("float"));
	x->x_outchordname = outlet_new(&x->x_ob, gensym("symbol"));
	x->x_outchordinversion = outlet_new(&x->x_ob, gensym("float"));
	x->x_outchordnotes = outlet_new(&x->x_ob, gensym("float"));

	x->x_split = (t_int)f;
	if(x->x_split == 0)x->x_split = 128;
	for(i = 0; i < MAX_POLY; i++)x->x_alloctable[i] = -1;
    
#ifndef MAXLIB
    post(version);
#endif
    return (void *)x;
}

void chord_setup(void)
{
    chord_class = class_new(gensym("chord"), (t_newmethod)chord_new,
    	0, sizeof(t_chord), 0, A_DEFFLOAT, 0);
    class_addfloat(chord_class, chord_float);
    class_addmethod(chord_class, (t_method)chord_ft1, gensym("ft1"), A_FLOAT, 0);
    class_sethelpsymbol(chord_class, gensym("maxlib/help-chord.pd"));
}