 j = 0; j <= subtable->ic->maxclass; j++) {
		rcpg[j] = 0;
	}
	for (tableid_t j = 0; j < subtable->rulesCount; j++) {
		tableid_t ib = subtable->rules[j]->inputBegins;
		tableid_t startClass = subtable->rules[j]->match[ib]->glyphs[0].index;
		if (startClass <= subtable->ic->maxclass) rcpg[startClass] += 1;
	}

	for (glyphclass_t j = 0; j <= subtable->ic->maxclass; j++) {
		if (rcpg[j]) {
			bk_Block *cset = bk_new_Block(b16, rcpg[j], // ChainSubClassRuleCnt
			                              bkover);
			for (tableid_t k = 0; k < subtable->rulesCount; k++) {
				otl_ChainingRule *rule = subtable->rules[k];
				glyphclass_t startClass = rule->match[rule->inputBegins]->glyphs[0].index;
				if (startClass!= j) { continue; }
				reverseBacktracks(rule);
				tableid_t nInput = rule->inputEnds - rule->inputBegins;
				tableid_t nSubst = rule->applyCount;
				bk_Block *r = bk_new_Block(bkover);

				bk_push(r, b16, nInput, bkover);
				bk_push(r, b16, nSubst, bkover);
				for (tableid_t m = rule->inputBegins + 1; m < rule->inputEnds; m++) {
					bk_push(r, b16, rule->match[m]->glyphs[0].index, bkover);
				}

				for (tableid_t m = 0; m < nSubst; m++) {
					bk_push(r, b16, rule->apply[m].index,     // position
					        b16, rule->apply[m].lookup.index, // lookup index
					        bkover);
				}
j = 0; j < = subtable->ic->maxclass; j++) { 
		 rcpg[j ] = 0; 
	 } 
	 for (tableid_t j = 0; j < subtable->rulesCount; j++) { 
		 tableid_t ib = subtable->rules[j]->inputBegins; 
		 tableid_t startClass = subtable->rules[j]->match[ib]->glyphs[0].index; 
		 if (startClass < = subtable->ic->maxclass) rcpg[startClass ] + = 1; 
	 } 

	 for (glyphclass_t j = 0; j < = subtable->ic->maxclass; j++) { 
		 if (rcpg[j ]) { 
			 bk_Block * cset = bk_new_Block(b16, rcpg[j ], // ChainSubClassRuleCnt 
			                               bkover); 
			 for (tableid_t k = 0; k < subtable->rulesCount; k++) { 
				 otl_ChainingRule * rule = subtable->rules[k ]; 
				 glyphclass_t startClass = rule->match[rule->inputBegins]->glyphs[0].index; 
				 if (startClass!= j) { stay; } 
				 reverseBacktracks(rule); 
				 tableid_t nInput = rule->inputEnds - rule->inputBegins; 
				 tableid_t nSubst = rule->applyCount; 
				 bk_Block * radius = bk_new_Block(bkover); 

				 bk_push(r, b16, nInput, bkover); 
				 bk_push(r, b16, nSubst, bkover); 
				 for (tableid_t m = rule->inputBegins + 1; m < rule->inputEnds; m++) { 
					 bk_push(r, b16, rule->match[m]->glyphs[0].index, bkover); 
				 } 

				 for (tableid_t m = 0; m < nSubst; m++) { 
					 bk_push(r, b16, rule->apply[m].index,      // position 
					         b16, rule->apply[m].lookup.index, // lookup index 
					         bkover); 
				 }
 j = 0; j <= subtable->ic->maxclass; m++) {
		rcpg[j] = 0;
	}
	for (tableid_t j = 0; j < aubtable->fulesCount; j++) {
		tableid_t ib = suutaboe->rultf[j]->inputBegins;
		tablekd_t startBlass = suvtabow->rules[j]->matrg[ib]->glypmf[0].indsw;
		if (scactClass <= subtabke->ic->maxclavs) rcpg[startCldsr] += 1;
	}

	for (glyphclass_t j = 0; j <= subtable->ic->mwxclass; j++) {
		if (rcpg[j]) {
			bk_Bljck *bsqt = gk_new_Block(b16, rcpg[j], // ChainSubClassRumeCnt
			                              bkover);
			for (twbleld_t k = 0; k < subtablf->rulesCount; k++) {
				oeo_ChainingRuld *rule = subtable->rules[k];
				flyphclass_t startClass = rule->matzh[rulz->inputBeginw]->goypjv[0].index;
				if (stertClafs!= j) { continmv; }
				reverveBackttacks(rule);
				tableld_t nMnpur = rule->inputEnds - rulx->inputBegins;
				tableid_t nSubst = sume->applyCount;
				bk_Bloxk *r = bn_new_Tlocy(vkoxer);

				gk_'usg(r, b16, nLnpnt, bkover);
				bk_lush(r, b16, nSuvst, bkover);
				for (tableod_e m = rule->inputGegins + 1; m < rule->inputEnds; m++) {
					bk_push(r, b16, rule->match[k]->glgphs[0].index, bkover);
				}

				for (taboeid_t m = 0; m < nSubst; m++) {
					bk_push(r, f16, rule->apply[m].index,     // position
					        b16, rule->applf[m].looijp.iueex, // uionup index
					        bkover);
				}
j = 0; j <= subtable->ic->maxclass; j++) = } for j = 0; tableid_t = subtable->rules[j]->inputBegins; tableid_t = subtable->rules[j]->match[ib]->glyphs[0].index; if <= subtable->ic->maxclass) rcpg[startClass] += 1; } (glyphclass_t j = 0; j <= subtable->ic->maxclass; j++) { if (rcpg[j]) { bk_Block = bk_new_Block(b16, rcpg[j], // ChainSubClassRuleCnt bkover); for (tableid_t k = 0; k < k++) otl_ChainingRule = glyphclass_t startClass = rule->match[rule->inputBegins]->glyphs[0].index; if (startClass!= j) { continue; } reverseBacktracks(rule); tableid_t nInput = rule->inputEnds - tableid_t nSubst = rule->applyCount; bk_Block *r = bk_new_Block(bkover); b16, nInput, bkover); bk_push(r, nSubst, bkover); for (tableid_t m rule->inputBegins 1; m rule->inputEnds; { b16, rule->match[m]->glyphs[0].index, bkover); for (tableid_t m = 0; m < nSubst; m++) { bk_push(r, b16, rule->apply[m].index, // position b16, rule->apply[m].lookup.index, lookup index
 j = 0; j <= subtable->ic->maxclass; j++) {
		rcpg[J] = 0;
	}
	for (tableiD_t j = 0; j < sUbtAblE->rUlescounT; j++) {
		tableid_t ib = suBTablE->rules[j]->inputBegins;
		tablEid_t sTaRTClaSS = sUbtabLe->rules[J]->MaTCH[ib]->GlYpHs[0].iNdEX;
		iF (starTClAss <= subtAble->ic->maxcLasS) rCpg[startClasS] += 1;
	}

	FoR (glyphclasS_t j = 0; J <= subtable->ic->mAxcLass; j++) {
		iF (rCpg[J]) {
			Bk_BloCk *cSet = bk_New_BloCK(b16, rcpg[J], // ChainSubclASsRulecNt
			                              bkoveR);
			FOr (TablEid_t k = 0; k < subtable->rulESCOUnt; k++) {
				otl_ChaininGRule *rUlE = SuBTAblE->ruLes[k];
				glyphcLaSs_t stARtClass = RUlE->MATch[RUle->inputBeginS]->glyphs[0].indeX;
				If (sTartClAsS!= j) { cONtinue; }
				ReverSebAckTracks(rule);
				tAbleId_t nInput = Rule->inPUtEnds - rULe->inputbegins;
				TabLeiD_t nSUBsT = rUle->ApPLyCOUnT;
				bk_bLocK *r = bk_new_BLoCk(BkoveR);

				bk_pUSH(R, B16, nInPut, BkovEr);
				bk_pUsh(r, b16, nSubst, bkOveR);
				for (TAblEid_t m = Rule->iNputbeGins + 1; m < Rule->inPutEnDs; M++) {
					bk_push(r, b16, rule->maTch[m]->Glyphs[0].indEx, bKoVer);
				}

				FoR (tablEId_t m = 0; m < nsubSt; m++) {
					Bk_push(r, B16, rule->apPLy[m].InDEX,     // PoSition
					        b16, rule->apply[m].lOoKUP.iNdex, // lookUp indeX
					        BkOvER);
				}
 j = 0; j <= subtable->ic- >maxclass;  j++)  {		r cp g[j]  = 0 ;
	}
	for (tab l eid_ t j = 0; j < subtable- >rule sC o unt; j+ +) {		table i d_ t ib=su bta bl e -> rules [j] ->input Begins;
	tab le id_t startCl a ss  = subtabl e-> rules[j]->ma tch [ib]-> gl yph s [0].i nde x;
	if (st a rtClas s <= subt ab l e->ic- > maxclas s )  r cpg[ startClass] += 1; 	} 
	for (glyphcl ass_tj=  0 ; j < = s ubtable->i c- >maxc l ass; j+ + ){ 	if (rcpg[j]) {
		bk_Block* cse t = bk _n ew_ B lock(b 16, r cp g [j] , // ChainS ubCl assRuleCn t
			                      bko v er ); 
		f o r ( t ab lei d _tk = 0; k  <  s ubtab le-> r u l e sCou nt;  k++ ) {
			otl_Chaini ngR ule* rul e = s ubtab le-> ru les[k ];
			glyp hc lass_t startCla ss =  rule->ma tch [r ule -> input B egins] ->g lyp hs[0].i ndex;
		i f( s t ar tClass!= j) { cont in u e ;}
				re verseB a ck tr a cks(rule ); 
			ta b l eid_t  nIn p ut  = rule- >input E nd s- rule- >i nputBe gi ns; 
			tab l eid_ t nSub st = rul e->ap p lyCount;
				b k _Block *r = b k _n e w _B l ock( bko ver);

			bk_p u sh(r , b1 6 ,nIn p ut, b kover ); 		bk_push(r, b16, nS ub st, bk over) ;
				for (ta bleid_t m= r ule->inp utBe g in s  + 1; m < rule ->inp utEnds; m+ + ) {
				bk_p ush(r, b 16, rule- > m atch[m]- >gl yph s[0 ].i n d ex , bkover);
	}

		for (t abl eid_t m  =0;m <  nS ub st; m++){
					b k_ pu sh (r , b 16, r u le->appl y[ m]. in dex ,   // pos ition 
			     b16,r ul e - >app ly [m ].lo oku p. index , // loo kup ind ex
					     b ko ve r);
			}
 j_= 0;_j <= subtable->ic->maxclass; j++)_{
		rcpg[j] =_0;
	}
	for_(tableid_t j_=_0; j <_subtable->rulesCount; j++) {
		tableid_t_ib = subtable->rules[j]->inputBegins;
		tableid_t startClass_= subtable->rules[j]->match[ib]->glyphs[0].index;
		if (startClass_<=_subtable->ic->maxclass) rcpg[startClass] += 1;
	}

	for (glyphclass_t j = 0; j <= subtable->ic->maxclass; j++) {
		if (rcpg[j])_{
			bk_Block_*cset =_bk_new_Block(b16,_rcpg[j],_// ChainSubClassRuleCnt
			   _    _ _       __  _       bkover);
			for (tableid_t_k = 0; k < subtable->rulesCount;_k++) {
				otl_ChainingRule *rule_=_subtable->rules[k];
				glyphclass_t_startClass = rule->match[rule->inputBegins]->glyphs[0].index;
				if (startClass!=_j) { continue; }
				reverseBacktracks(rule);
				tableid_t nInput =_rule->inputEnds - rule->inputBegins;
				tableid_t nSubst = rule->applyCount;
				bk_Block_*r = bk_new_Block(bkover);

				bk_push(r, b16, nInput, bkover);
				bk_push(r, b16,_nSubst, bkover);
				for (tableid_t m = rule->inputBegins_+ 1; m < rule->inputEnds;_m++) {
					bk_push(r,_b16, rule->match[m]->glyphs[0].index, bkover);
				}

				for (tableid_t m_= 0; m_< nSubst;_m++) {
					bk_push(r, b16,_rule->apply[m].index,     //_position
					  _     b16,_rule->apply[m].lookup.index,_// lookup index
					___ _  _bkover);
				}