[gnu.gcc.bug] Bug in GCC V1.36 on SUN4/260.

bruce@ic.cmc.ca (Bruce Keats) (10/23/89)

	I think I have found a bug in the GNU C compiler, V1.36.
I compiled the enclosed C source on a SUN4/260 running SUNOs 4.0.3
and discovered that whenever the last case in the switch statement
was executed (case 2253 before the default action) the program
got a segmentation violation.  The problem appears to be with the
assembler code produced for the case.  The following is what the
compiler produces for that case in the switch.

	L747:
	.stabn 68,0,8904,LM6641
	LM6641:
		sethi %hi(_temp_cin),%o0
		or %lo(_temp_cin),%o0,%o0
		ld [%o2+2296],%l3
		st %l3,[%o0]
	.stabn 68,0,8905,LM6642
	LM6642:
		ld [%l1+2296],%l3
		st %l3,[%o0+4]
	.stabn 68,0,8906,LM6643
	LM6643:
		sethi %hi(8448),%o0
		or %lo(8448),%o0,%o0
		ld [%o2+%o0],%l3
		st %l3,[%o0+8]
	.stabn 68,0,8907,LM6644
	LM6644:
		ld [%l1+%o0],%l3
		st %l3,[%o0+12]
	.stabn 68,0,8908,LM6645
	LM6645:
		sethi %hi(_temp_cout),%o0
		or %lo(_temp_cout),%o0,%o0
		sethi %hi(9012),%l0
		or %lo(9012),%l0,%l0
		ld [%o2+%l0],%l3
		st %l3,[%o0]
	.stabn 68,0,8909,LM6646
	LM6646:
		mov %o4,%o0
		mov %o5,%o1
		sethi %hi(_cin_ptr),%o2
		or %lo(_cin_ptr),%o2,%o2
		sethi %hi(_cout_ptr),%o3
		call _nand_2_inject,0
		or %o3,%lo(_cout_ptr),%o3
	.stabn 68,0,8910,LM6647
	LM6647:
		sethi %hi(_cout_ptr),%g1
		ld	[%g1+%lo(_cout_ptr)],%o0
		ld [%o0],%l3
		st %l3,[%l1+%l0]
	.stabn 68,0,8911,LM6648
	LM6648:
		mov %l2,%o0
		ld [%o0],%o1
		add %o1,1,%o1
		st %o1,[%o0]
	.stabn 68,0,8912,LM6649
	LM6649:

	Notice the code produced for line 8904 (label LM6641)
and line 8906 (label LM6643).  After line 8904 is executed,
register %o0 contains the base address of the array "temp_cin".
In calculating "prev_out[2112] as part of line 8906, register
%o0 is used as a scratch register - holding the offset into
the array "prev_out" (base address stored in register %o2).
The problem is that once the value is fetched from
"prev_out[2112]", GCC assumes that register %o0 still contains
the base address for the array "temp_cin" (from line 8904).

	I tried to find a simpler case which would uncover
the problem, but to no avail.  Every time I tried commenting
out a single line, GCC would use register %o1 to hold the
offset into the array "prev_out" (which is ok).

					Bruce Keats
					Dept. of Electrical Engineering
					Queen's University at Kingston
					Kingston, Ontario

					    bruce@eleceng.ee.queensu.ca
					OR: bruce@ic.cmc.ca (prefered)

------------------------ test.c ----------------------------------
# 1 "test.c"
# 1 "../../cscan/library.h" 1
# 1 "../../cscan/defs.h" 1
 






# 1 "/usr/include/sys/types.h" 1
 

 








 



# 1 "/usr/include/sys/sysmacros.h" 1
 

 





 


 


 



# 16 "/usr/include/sys/types.h" 2


typedef	unsigned char	u_char;
typedef	unsigned short	u_short;
typedef	unsigned int	u_int;
typedef	unsigned long	u_long;
typedef	unsigned short	ushort;		 
typedef	unsigned int	uint;		 














typedef struct  _physadr { int r[1]; } *physadr;
typedef struct label_t {
	int     val[2];
} label_t;







typedef	struct	_quad { long val[2]; } quad;
typedef	long	daddr_t;
typedef	char *	caddr_t;
typedef	u_long	ino_t;
typedef	long	swblk_t;
typedef	int	size_t;
typedef	long	time_t;
typedef	short	dev_t;
typedef	long	off_t;
typedef	u_short	uid_t;
typedef	u_short	gid_t;
typedef	long	key_t;


 









typedef	long	fd_mask;









typedef	struct fd_set {
	fd_mask	fds_bits[(((256 )+(( (sizeof(fd_mask) * 8		)	)-1))/( (sizeof(fd_mask) * 8		)	)) ];
} fd_set;

typedef	char *	addr_t;






# 107 "/usr/include/sys/types.h"



# 8 "../../cscan/defs.h" 2





typedef	enum	bool		Bool;



typedef	enum	state		Sigstate;
typedef	u_char			*Bitfield;











































enum	bool
{
	TRUE		= 1,
	FALSE		= 0
};













enum	state
{
	STA_0		= 0,
	STA_X		= 1,
	STA_Z		= 2,
	STA_1		= 3,
	STA_REP		= 4
};







 
















 








 









 













































# 1 "../../cscan/library.h" 2

# 1 "../../cscan/vector.h" 1
 






typedef	int			Tvec;
typedef	struct	vector_head	Vheader;
typedef	struct	test_sequence	Tseq;

struct	vector_head
{
	u_short		vh_magic;
	u_short		vh_vecnt;
};

struct	test_sequence
{
	Vheader		ts_rec;




	Tvec		**ts_prim,
			**ts_scan;
};


































extern	Tseq		*alloc_tseqarray(),
			*realloc_tseqarray();
extern	Tvec		*alloc_tvecarray(),
			**alloc_tveclist();
extern	void		free_tseqarray(),
			free_tvecarray(),
			free_tveclist(),
			finis_write_vector(),
			cache_testseq();


# 2 "../../cscan/library.h" 2

# 1 "../../cscan/glob.h" 1
 





























































































# 3 "../../cscan/library.h" 2





typedef	struct	call_seq	Callseq;
typedef	struct	cir_desc	Cdesc;

struct	call_seq
{
	int		cs_startflt;
};

struct	cir_desc
{
	char		*cd_name;
	int		cd_paramcnt,
			cd_incnt,
			cd_outcnt,
			cd_scancnt,
			cd_faultcnt,
			cd_symbolcnt,
			cd_outputsize;
};

extern	Callseq		symbols[];


# 1 "test.c" 2

# 1 "c7552_3_defs.h" 1
extern	void		not_inject();
extern	void		nxor_2_inject();
extern	void		nxor_3_inject();
extern	void		nxor_4_inject();
extern	void		nxor_5_inject();
extern	void		nxor_6_inject();
extern	void		nxor_7_inject();
extern	void		nxor_8_inject();
extern	void		nxor_9_inject();
extern	void		or_2_inject();
extern	void		or_3_inject();
extern	void		or_4_inject();
extern	void		or_5_inject();
extern	void		or_6_inject();
extern	void		or_7_inject();
extern	void		or_8_inject();
extern	void		or_9_inject();
extern	void		and_2_inject();
extern	void		and_3_inject();
extern	void		and_4_inject();
extern	void		and_5_inject();
extern	void		and_6_inject();
extern	void		and_7_inject();
extern	void		and_8_inject();
extern	void		and_9_inject();
extern	void		nor_2_inject();
extern	void		nor_3_inject();
extern	void		nor_4_inject();
extern	void		nor_5_inject();
extern	void		nor_6_inject();
extern	void		nor_7_inject();
extern	void		nor_8_inject();
extern	void		nor_9_inject();
extern	void		xor_2_inject();
extern	void		xor_3_inject();
extern	void		xor_4_inject();
extern	void		xor_5_inject();
extern	void		xor_6_inject();
extern	void		xor_7_inject();
extern	void		xor_8_inject();
extern	void		xor_9_inject();
extern	void		nand_2_inject();
extern	void		nand_3_inject();
extern	void		nand_4_inject();
extern	void		nand_5_inject();
extern	void		nand_6_inject();
extern	void		nand_7_inject();
extern	void		nand_8_inject();
extern	void		nand_9_inject();
extern	void		wire_inject();

extern	Cdesc		cd_c7552_3;

extern	void		first_time_c7552_3();



extern	Callseq			symbols [];

extern	void		c7552_3();



# 2 "test.c" 2


static	Tvec		temp_cin[9][2],
			temp_cout[1][2];
static	Tvec		*cin_ptr[9] = {
		& temp_cin[0][1],
		& temp_cin[1][1],
		& temp_cin[2][1],
		& temp_cin[3][1],
		& temp_cin[4][1],
		& temp_cin[5][1],
		& temp_cin[6][1],
		& temp_cin[7][1],
		& temp_cin[8][1],
	},
			*cout_ptr[1] = {
		& temp_cout[0][1],
	};

fault_c7552_3_1510(outputs, seq_num, fault_no, sym, vecnt,
		   in_params, scan_in, out_params, scan_out)
	int		seq_num,
			fault_no,
			vecnt,
			*sym;
	Tvec		**outputs,
			**in_params,
			**scan_in,
			**out_params,
			**scan_out;
{
	register Tvec	*out = outputs[seq_num],
			*prev_out = outputs[seq_num - 1];

	if (*sym < 2265)
	switch (*sym)
	{
	 
	case 1510:
		temp_cin[0][0] = prev_out[78];
		temp_cin[0][1] = out[78];
		temp_cout[0][0] = prev_out[1510];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1510] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1511:
		temp_cin[0][0] = prev_out[578];
		temp_cin[0][1] = out[578];
		temp_cout[0][0] = prev_out[1511];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1511] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1512:
		temp_cin[0][0] = prev_out[630];
		temp_cin[0][1] = out[630];
		temp_cout[0][0] = prev_out[1512];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1512] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1513:
		temp_cin[0][0] = prev_out[46];
		temp_cin[0][1] = out[46];
		temp_cout[0][0] = prev_out[1513];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1513] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1514:
		temp_cin[0][0] = prev_out[81];
		temp_cin[0][1] = out[81];
		temp_cout[0][0] = prev_out[1514];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1514] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1515:
		temp_cin[0][0] = prev_out[44];
		temp_cin[0][1] = out[44];
		temp_cout[0][0] = prev_out[1515];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1515] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1516:
		temp_cin[0][0] = prev_out[75];
		temp_cin[0][1] = out[75];
		temp_cout[0][0] = prev_out[1516];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1516] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1517:
		temp_cin[0][0] = prev_out[174];
		temp_cin[0][1] = out[174];
		temp_cout[0][0] = prev_out[1517];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1517] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1518:
		temp_cin[0][0] = prev_out[208];
		temp_cin[0][1] = out[208];
		temp_cout[0][0] = prev_out[1518];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1518] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1519:
		temp_cin[0][0] = prev_out[249];
		temp_cin[0][1] = out[249];
		temp_cin[1][0] = prev_out[1289];
		temp_cin[1][1] = out[1289];
		temp_cout[0][0] = prev_out[1519];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1519] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1520:
		temp_cin[0][0] = prev_out[199];
		temp_cin[0][1] = out[199];
		temp_cin[1][0] = prev_out[1290];
		temp_cin[1][1] = out[1290];
		temp_cout[0][0] = prev_out[1520];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1520] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1521:
		temp_cin[0][0] = prev_out[57];
		temp_cin[0][1] = out[57];
		temp_cin[1][0] = prev_out[38];
		temp_cin[1][1] = out[38];
		temp_cout[0][0] = prev_out[1521];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1521] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1522:
		temp_cin[0][0] = prev_out[1292];
		temp_cin[0][1] = out[1292];
		temp_cin[1][0] = prev_out[1291];
		temp_cin[1][1] = out[1291];
		temp_cout[0][0] = prev_out[1522];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1522] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1523:
		temp_cin[0][0] = prev_out[60];
		temp_cin[0][1] = out[60];
		temp_cin[1][0] = prev_out[39];
		temp_cin[1][1] = out[39];
		temp_cout[0][0] = prev_out[1523];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1523] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1524:
		temp_cin[0][0] = prev_out[1294];
		temp_cin[0][1] = out[1294];
		temp_cin[1][0] = prev_out[1293];
		temp_cin[1][1] = out[1293];
		temp_cout[0][0] = prev_out[1524];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1524] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1525:
		temp_cin[0][0] = prev_out[63];
		temp_cin[0][1] = out[63];
		temp_cin[1][0] = prev_out[40];
		temp_cin[1][1] = out[40];
		temp_cout[0][0] = prev_out[1525];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1525] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1526:
		temp_cin[0][0] = prev_out[1296];
		temp_cin[0][1] = out[1296];
		temp_cin[1][0] = prev_out[1295];
		temp_cin[1][1] = out[1295];
		temp_cout[0][0] = prev_out[1526];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1526] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1527:
		temp_cin[0][0] = prev_out[192];
		temp_cin[0][1] = out[192];
		temp_cin[1][0] = prev_out[158];
		temp_cin[1][1] = out[158];
		temp_cout[0][0] = prev_out[1527];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1527] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1528:
		temp_cin[0][0] = prev_out[1298];
		temp_cin[0][1] = out[1298];
		temp_cin[1][0] = prev_out[1297];
		temp_cin[1][1] = out[1297];
		temp_cout[0][0] = prev_out[1528];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1528] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1529:
		temp_cin[0][0] = prev_out[246];
		temp_cin[0][1] = out[246];
		temp_cin[1][0] = prev_out[1299];
		temp_cin[1][1] = out[1299];
		temp_cout[0][0] = prev_out[1529];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1529] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1530:
		temp_cin[0][0] = prev_out[198];
		temp_cin[0][1] = out[198];
		temp_cin[1][0] = prev_out[1300];
		temp_cin[1][1] = out[1300];
		temp_cout[0][0] = prev_out[1530];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1530] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1531:
		temp_cin[0][0] = prev_out[370];
		temp_cin[0][1] = out[370];
		temp_cin[1][0] = prev_out[1301];
		temp_cin[1][1] = out[1301];
		temp_cout[0][0] = prev_out[1531];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1531] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1532:
		temp_cin[0][0] = prev_out[310];
		temp_cin[0][1] = out[310];
		temp_cin[1][0] = prev_out[1302];
		temp_cin[1][1] = out[1302];
		temp_cout[0][0] = prev_out[1532];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1532] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1533:
		temp_cin[0][0] = prev_out[906];
		temp_cin[0][1] = out[906];
		temp_cin[1][0] = prev_out[1303];
		temp_cin[1][1] = out[1303];
		temp_cout[0][0] = prev_out[1533];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1533] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1534:
		temp_cin[0][0] = prev_out[756];
		temp_cin[0][1] = out[756];
		temp_cin[1][0] = prev_out[1304];
		temp_cin[1][1] = out[1304];
		temp_cout[0][0] = prev_out[1534];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1534] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1535:
		temp_cin[0][0] = prev_out[215];
		temp_cin[0][1] = out[215];
		temp_cout[0][0] = prev_out[1535];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1535] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1536:
		temp_cin[0][0] = prev_out[277];
		temp_cin[0][1] = out[277];
		temp_cout[0][0] = prev_out[1536];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1536] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1537:
		temp_cin[0][0] = prev_out[783];
		temp_cin[0][1] = out[783];
		temp_cout[0][0] = prev_out[1537];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1537] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1538:
		temp_cin[0][0] = prev_out[929];
		temp_cin[0][1] = out[929];
		temp_cout[0][0] = prev_out[1538];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1538] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1539:
		temp_cin[0][0] = prev_out[38];
		temp_cin[0][1] = out[38];
		temp_cout[0][0] = prev_out[1539];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1539] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1540:
		temp_cin[0][0] = prev_out[57];
		temp_cin[0][1] = out[57];
		temp_cout[0][0] = prev_out[1540];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1540] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1541:
		temp_cin[0][0] = prev_out[231];
		temp_cin[0][1] = out[231];
		temp_cin[1][0] = prev_out[1305];
		temp_cin[1][1] = out[1305];
		temp_cout[0][0] = prev_out[1541];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1541] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1542:
		temp_cin[0][0] = prev_out[190];
		temp_cin[0][1] = out[190];
		temp_cin[1][0] = prev_out[1306];
		temp_cin[1][1] = out[1306];
		temp_cout[0][0] = prev_out[1542];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1542] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1543:
		temp_cin[0][0] = prev_out[1205];
		temp_cin[0][1] = out[1205];
		temp_cin[1][0] = prev_out[1307];
		temp_cin[1][1] = out[1307];
		temp_cout[0][0] = prev_out[1543];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1543] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1544:
		temp_cin[0][0] = prev_out[1156];
		temp_cin[0][1] = out[1156];
		temp_cin[1][0] = prev_out[1308];
		temp_cin[1][1] = out[1308];
		temp_cout[0][0] = prev_out[1544];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1544] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1545:
		temp_cin[0][0] = prev_out[1048];
		temp_cin[0][1] = out[1048];
		temp_cin[1][0] = prev_out[1309];
		temp_cin[1][1] = out[1309];
		temp_cout[0][0] = prev_out[1545];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1545] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1546:
		temp_cin[0][0] = prev_out[1047];
		temp_cin[0][1] = out[1047];
		temp_cin[1][0] = prev_out[1310];
		temp_cin[1][1] = out[1310];
		temp_cout[0][0] = prev_out[1546];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1546] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1547:
		temp_cin[0][0] = prev_out[1211];
		temp_cin[0][1] = out[1211];
		temp_cin[1][0] = prev_out[1311];
		temp_cin[1][1] = out[1311];
		temp_cout[0][0] = prev_out[1547];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1547] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1548:
		temp_cin[0][0] = prev_out[1161];
		temp_cin[0][1] = out[1161];
		temp_cin[1][0] = prev_out[1312];
		temp_cin[1][1] = out[1312];
		temp_cout[0][0] = prev_out[1548];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1548] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1549:
		temp_cin[0][0] = prev_out[1050];
		temp_cin[0][1] = out[1050];
		temp_cin[1][0] = prev_out[1313];
		temp_cin[1][1] = out[1313];
		temp_cout[0][0] = prev_out[1549];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1549] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1550:
		temp_cin[0][0] = prev_out[1049];
		temp_cin[0][1] = out[1049];
		temp_cin[1][0] = prev_out[1314];
		temp_cin[1][1] = out[1314];
		temp_cout[0][0] = prev_out[1550];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1550] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1551:
		temp_cin[0][0] = prev_out[1316];
		temp_cin[0][1] = out[1316];
		temp_cin[1][0] = prev_out[1315];
		temp_cin[1][1] = out[1315];
		temp_cout[0][0] = prev_out[1551];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1551] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1552:
		temp_cin[0][0] = prev_out[1051];
		temp_cin[0][1] = out[1051];
		temp_cin[1][0] = prev_out[1317];
		temp_cin[1][1] = out[1317];
		temp_cout[0][0] = prev_out[1552];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1552] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1553:
		temp_cin[0][0] = prev_out[829];
		temp_cin[0][1] = out[829];
		temp_cin[1][0] = prev_out[787];
		temp_cin[1][1] = out[787];
		temp_cout[0][0] = prev_out[1553];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1553] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1554:
		temp_cin[0][0] = prev_out[1319];
		temp_cin[0][1] = out[1319];
		temp_cin[1][0] = prev_out[1318];
		temp_cin[1][1] = out[1318];
		temp_cout[0][0] = prev_out[1554];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1554] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1555:
		temp_cin[0][0] = prev_out[985];
		temp_cin[0][1] = out[985];
		temp_cin[1][0] = prev_out[940];
		temp_cin[1][1] = out[940];
		temp_cout[0][0] = prev_out[1555];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1555] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1556:
		temp_cin[0][0] = prev_out[1321];
		temp_cin[0][1] = out[1321];
		temp_cin[1][0] = prev_out[1320];
		temp_cin[1][1] = out[1320];
		temp_cout[0][0] = prev_out[1556];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1556] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1557:
		temp_cin[0][0] = prev_out[1056];
		temp_cin[0][1] = out[1056];
		temp_cin[1][0] = prev_out[942];
		temp_cin[1][1] = out[942];
		temp_cout[0][0] = prev_out[1557];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1557] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1558:
		temp_cin[0][0] = prev_out[1323];
		temp_cin[0][1] = out[1323];
		temp_cin[1][0] = prev_out[1322];
		temp_cin[1][1] = out[1322];
		temp_cout[0][0] = prev_out[1558];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1558] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1559:
		temp_cin[0][0] = prev_out[1171];
		temp_cin[0][1] = out[1171];
		temp_cout[0][0] = prev_out[1559];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1559] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1560:
		temp_cin[0][0] = prev_out[1221];
		temp_cin[0][1] = out[1221];
		temp_cout[0][0] = prev_out[1560];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1560] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1561:
		temp_cin[0][0] = prev_out[1166];
		temp_cin[0][1] = out[1166];
		temp_cout[0][0] = prev_out[1561];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1561] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1562:
		temp_cin[0][0] = prev_out[1216];
		temp_cin[0][1] = out[1216];
		temp_cout[0][0] = prev_out[1562];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1562] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1563:
		temp_cin[0][0] = prev_out[953];
		temp_cin[0][1] = out[953];
		temp_cout[0][0] = prev_out[1563];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1563] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1564:
		temp_cin[0][0] = prev_out[997];
		temp_cin[0][1] = out[997];
		temp_cout[0][0] = prev_out[1564];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1564] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1565:
		temp_cin[0][0] = prev_out[951];
		temp_cin[0][1] = out[951];
		temp_cout[0][0] = prev_out[1565];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1565] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1566:
		temp_cin[0][0] = prev_out[995];
		temp_cin[0][1] = out[995];
		temp_cout[0][0] = prev_out[1566];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1566] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1567:
		temp_cin[0][0] = prev_out[798];
		temp_cin[0][1] = out[798];
		temp_cout[0][0] = prev_out[1567];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1567] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1568:
		temp_cin[0][0] = prev_out[834];
		temp_cin[0][1] = out[834];
		temp_cout[0][0] = prev_out[1568];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1568] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1569:
		temp_cin[0][0] = prev_out[1316];
		temp_cin[0][1] = out[1316];
		temp_cin[1][0] = prev_out[1051];
		temp_cin[1][1] = out[1051];
		temp_cout[0][0] = prev_out[1569];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1569] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1570:
		temp_cin[0][0] = prev_out[1050];
		temp_cin[0][1] = out[1050];
		temp_cin[1][0] = prev_out[1049];
		temp_cin[1][1] = out[1049];
		temp_cout[0][0] = prev_out[1570];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1570] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1571:
		temp_cin[0][0] = prev_out[1211];
		temp_cin[0][1] = out[1211];
		temp_cin[1][0] = prev_out[1161];
		temp_cin[1][1] = out[1161];
		temp_cout[0][0] = prev_out[1571];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1571] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1572:
		temp_cin[0][0] = prev_out[1048];
		temp_cin[0][1] = out[1048];
		temp_cin[1][0] = prev_out[1047];
		temp_cin[1][1] = out[1047];
		temp_cout[0][0] = prev_out[1572];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1572] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1573:
		temp_cin[0][0] = prev_out[829];
		temp_cin[0][1] = out[829];
		temp_cin[1][0] = prev_out[1324];
		temp_cin[1][1] = out[1324];
		temp_cout[0][0] = prev_out[1573];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1573] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1574:
		temp_cin[0][0] = prev_out[787];
		temp_cin[0][1] = out[787];
		temp_cin[1][0] = prev_out[1325];
		temp_cin[1][1] = out[1325];
		temp_cout[0][0] = prev_out[1574];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1574] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1575:
		temp_cin[0][0] = prev_out[1181];
		temp_cin[0][1] = out[1181];
		temp_cout[0][0] = prev_out[1575];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1575] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1576:
		temp_cin[0][0] = prev_out[1231];
		temp_cin[0][1] = out[1231];
		temp_cout[0][0] = prev_out[1576];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1576] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1577:
		temp_cin[0][0] = prev_out[968];
		temp_cin[0][1] = out[968];
		temp_cout[0][0] = prev_out[1577];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1577] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1578:
		temp_cin[0][0] = prev_out[1009];
		temp_cin[0][1] = out[1009];
		temp_cout[0][0] = prev_out[1578];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1578] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1579:
		temp_cin[0][0] = prev_out[1187];
		temp_cin[0][1] = out[1187];
		temp_cout[0][0] = prev_out[1579];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1579] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1580:
		temp_cin[0][0] = prev_out[1237];
		temp_cin[0][1] = out[1237];
		temp_cout[0][0] = prev_out[1580];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1580] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1581:
		temp_cin[0][0] = prev_out[973];
		temp_cin[0][1] = out[973];
		temp_cout[0][0] = prev_out[1581];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1581] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1582:
		temp_cin[0][0] = prev_out[1015];
		temp_cin[0][1] = out[1015];
		temp_cout[0][0] = prev_out[1582];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1582] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1583:
		temp_cin[0][0] = prev_out[1184];
		temp_cin[0][1] = out[1184];
		temp_cout[0][0] = prev_out[1583];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1583] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1584:
		temp_cin[0][0] = prev_out[1234];
		temp_cin[0][1] = out[1234];
		temp_cout[0][0] = prev_out[1584];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1584] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1585:
		temp_cin[0][0] = prev_out[1221];
		temp_cin[0][1] = out[1221];
		temp_cin[1][0] = prev_out[1171];
		temp_cin[1][1] = out[1171];
		temp_cout[0][0] = prev_out[1585];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1585] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1586:
		temp_cin[0][0] = prev_out[1327];
		temp_cin[0][1] = out[1327];
		temp_cin[1][0] = prev_out[1326];
		temp_cin[1][1] = out[1326];
		temp_cout[0][0] = prev_out[1586];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1586] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1587:
		temp_cin[0][0] = prev_out[1062];
		temp_cin[0][1] = out[1062];
		temp_cin[1][0] = prev_out[961];
		temp_cin[1][1] = out[961];
		temp_cout[0][0] = prev_out[1587];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1587] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1588:
		temp_cin[0][0] = prev_out[1329];
		temp_cin[0][1] = out[1329];
		temp_cin[1][0] = prev_out[1328];
		temp_cin[1][1] = out[1328];
		temp_cout[0][0] = prev_out[1588];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1588] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1589:
		temp_cin[0][0] = prev_out[1065];
		temp_cin[0][1] = out[1065];
		temp_cin[1][0] = prev_out[962];
		temp_cin[1][1] = out[962];
		temp_cout[0][0] = prev_out[1589];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1589] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1590:
		temp_cin[0][0] = prev_out[1331];
		temp_cin[0][1] = out[1331];
		temp_cin[1][0] = prev_out[1330];
		temp_cin[1][1] = out[1330];
		temp_cout[0][0] = prev_out[1590];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1590] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1591:
		temp_cin[0][0] = prev_out[1068];
		temp_cin[0][1] = out[1068];
		temp_cin[1][0] = prev_out[956];
		temp_cin[1][1] = out[956];
		temp_cout[0][0] = prev_out[1591];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1591] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1592:
		temp_cin[0][0] = prev_out[1333];
		temp_cin[0][1] = out[1333];
		temp_cin[1][0] = prev_out[1332];
		temp_cin[1][1] = out[1332];
		temp_cout[0][0] = prev_out[1592];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1592] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1593:
		temp_cin[0][0] = prev_out[813];
		temp_cin[0][1] = out[813];
		temp_cout[0][0] = prev_out[1593];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1593] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1594:
		temp_cin[0][0] = prev_out[841];
		temp_cin[0][1] = out[841];
		temp_cout[0][0] = prev_out[1594];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1594] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1595:
		temp_cin[0][0] = prev_out[964];
		temp_cin[0][1] = out[964];
		temp_cout[0][0] = prev_out[1595];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1595] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1596:
		temp_cin[0][0] = prev_out[1004];
		temp_cin[0][1] = out[1004];
		temp_cout[0][0] = prev_out[1596];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1596] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1597:
		temp_cin[0][0] = prev_out[966];
		temp_cin[0][1] = out[966];
		temp_cout[0][0] = prev_out[1597];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1597] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1598:
		temp_cin[0][0] = prev_out[1006];
		temp_cin[0][1] = out[1006];
		temp_cout[0][0] = prev_out[1598];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1598] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1599:
		temp_cin[0][0] = prev_out[1178];
		temp_cin[0][1] = out[1178];
		temp_cout[0][0] = prev_out[1599];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1599] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1600:
		temp_cin[0][0] = prev_out[1228];
		temp_cin[0][1] = out[1228];
		temp_cout[0][0] = prev_out[1600];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1600] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1601:
		temp_cin[0][0] = prev_out[1335];
		temp_cin[0][1] = out[1335];
		temp_cin[1][0] = prev_out[1334];
		temp_cin[1][1] = out[1334];
		temp_cout[0][0] = prev_out[1601];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1601] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1602:
		temp_cin[0][0] = prev_out[114];
		temp_cin[0][1] = out[114];
		temp_cin[1][0] = prev_out[1336];
		temp_cin[1][1] = out[1336];
		temp_cout[0][0] = prev_out[1602];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1602] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1603:
		temp_cin[0][0] = prev_out[280];
		temp_cin[0][1] = out[280];
		temp_cout[0][0] = prev_out[1603];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1603] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1604:
		temp_cin[0][0] = prev_out[1338];
		temp_cin[0][1] = out[1338];
		temp_cin[1][0] = prev_out[1337];
		temp_cin[1][1] = out[1337];
		temp_cout[0][0] = prev_out[1604];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1604] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1605:
		temp_cin[0][0] = prev_out[1604];
		temp_cin[0][1] = out[1604];
		temp_cout[0][0] = prev_out[1605];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1605] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1606:
		temp_cin[0][0] = prev_out[900];
		temp_cin[0][1] = out[900];
		temp_cout[0][0] = prev_out[1606];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1606] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1607:
		temp_cin[0][0] = prev_out[1340];
		temp_cin[0][1] = out[1340];
		temp_cin[1][0] = prev_out[1339];
		temp_cin[1][1] = out[1339];
		temp_cout[0][0] = prev_out[1607];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1607] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1608:
		temp_cin[0][0] = prev_out[1607];
		temp_cin[0][1] = out[1607];
		temp_cout[0][0] = prev_out[1608];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1608] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1609:
		temp_cin[0][0] = prev_out[900];
		temp_cin[0][1] = out[900];
		temp_cout[0][0] = prev_out[1609];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1609] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1610:
		temp_cin[0][0] = prev_out[1342];
		temp_cin[0][1] = out[1342];
		temp_cin[1][0] = prev_out[1341];
		temp_cin[1][1] = out[1341];
		temp_cout[0][0] = prev_out[1610];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1610] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1611:
		temp_cin[0][0] = prev_out[1610];
		temp_cin[0][1] = out[1610];
		temp_cout[0][0] = prev_out[1611];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1611] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1612:
		temp_cin[0][0] = prev_out[1344];
		temp_cin[0][1] = out[1344];
		temp_cin[1][0] = prev_out[1343];
		temp_cin[1][1] = out[1343];
		temp_cout[0][0] = prev_out[1612];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1612] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1613:
		temp_cin[0][0] = prev_out[124];
		temp_cin[0][1] = out[124];
		temp_cin[1][0] = prev_out[1345];
		temp_cin[1][1] = out[1345];
		temp_cout[0][0] = prev_out[1613];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1613] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1614:
		temp_cin[0][0] = prev_out[1346];
		temp_cin[0][1] = out[1346];
		temp_cin[1][0] = in_params[205][-1];
		temp_cin[1][1] = in_params[205][0];
		temp_cout[0][0] = prev_out[1614];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1614] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1615:
		temp_cin[0][0] = prev_out[1378];
		temp_cin[0][1] = out[1378];
		temp_cout[0][0] = prev_out[1615];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1615] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1616:
		temp_cin[0][0] = prev_out[1379];
		temp_cin[0][1] = out[1379];
		temp_cout[0][0] = prev_out[1616];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1616] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1617:
		temp_cin[0][0] = prev_out[1347];
		temp_cin[0][1] = out[1347];
		temp_cout[0][0] = prev_out[1617];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1617] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1618:
		temp_cin[0][0] = prev_out[296];
		temp_cin[0][1] = out[296];
		temp_cout[0][0] = prev_out[1618];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1618] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1619:
		temp_cin[0][0] = prev_out[1349];
		temp_cin[0][1] = out[1349];
		temp_cin[1][0] = prev_out[1348];
		temp_cin[1][1] = out[1348];
		temp_cout[0][0] = prev_out[1619];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1619] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1620:
		temp_cin[0][0] = prev_out[1619];
		temp_cin[0][1] = out[1619];
		temp_cout[0][0] = prev_out[1620];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1620] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1621:
		temp_cin[0][0] = prev_out[1352];
		temp_cin[0][1] = out[1352];
		temp_cout[0][0] = prev_out[1621];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1621] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1622:
		temp_cin[0][0] = prev_out[1351];
		temp_cin[0][1] = out[1351];
		temp_cin[1][0] = prev_out[1350];
		temp_cin[1][1] = out[1350];
		temp_cout[0][0] = prev_out[1622];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1622] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1623:
		temp_cin[0][0] = prev_out[1622];
		temp_cin[0][1] = out[1622];
		temp_cout[0][0] = prev_out[1623];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1623] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1624:
		temp_cin[0][0] = prev_out[1352];
		temp_cin[0][1] = out[1352];
		temp_cout[0][0] = prev_out[1624];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1624] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1625:
		temp_cin[0][0] = prev_out[1354];
		temp_cin[0][1] = out[1354];
		temp_cin[1][0] = prev_out[1353];
		temp_cin[1][1] = out[1353];
		temp_cout[0][0] = prev_out[1625];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1625] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1626:
		temp_cin[0][0] = prev_out[1625];
		temp_cin[0][1] = out[1625];
		temp_cout[0][0] = prev_out[1626];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1626] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1627:
		temp_cin[0][0] = prev_out[1356];
		temp_cin[0][1] = out[1356];
		temp_cin[1][0] = prev_out[1355];
		temp_cin[1][1] = out[1355];
		temp_cout[0][0] = prev_out[1627];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1627] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1628:
		temp_cin[0][0] = prev_out[133];
		temp_cin[0][1] = out[133];
		temp_cin[1][0] = prev_out[1357];
		temp_cin[1][1] = out[1357];
		temp_cout[0][0] = prev_out[1628];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1628] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1629:
		temp_cin[0][0] = prev_out[138];
		temp_cin[0][1] = out[138];
		temp_cin[1][0] = prev_out[140];
		temp_cin[1][1] = out[140];
		temp_cin[2][0] = prev_out[142];
		temp_cin[2][1] = out[142];
		temp_cin[3][0] = prev_out[322];
		temp_cin[3][1] = out[322];
		temp_cin[4][0] = prev_out[774];
		temp_cin[4][1] = out[774];
		temp_cout[0][0] = prev_out[1629];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1629] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1630:
		temp_cin[0][0] = prev_out[1359];
		temp_cin[0][1] = out[1359];
		temp_cin[1][0] = prev_out[1358];
		temp_cin[1][1] = out[1358];
		temp_cout[0][0] = prev_out[1630];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1630] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1631:
		temp_cin[0][0] = prev_out[1363];
		temp_cin[0][1] = out[1363];
		temp_cin[1][0] = prev_out[1362];
		temp_cin[1][1] = out[1362];
		temp_cin[2][0] = prev_out[1361];
		temp_cin[2][1] = out[1361];
		temp_cin[3][0] = prev_out[1360];
		temp_cin[3][1] = out[1360];
		temp_cout[0][0] = prev_out[1631];
		or_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1631] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1632:
		temp_cin[0][0] = prev_out[1368];
		temp_cin[0][1] = out[1368];
		temp_cin[1][0] = prev_out[1367];
		temp_cin[1][1] = out[1367];
		temp_cin[2][0] = prev_out[1366];
		temp_cin[2][1] = out[1366];
		temp_cin[3][0] = prev_out[1365];
		temp_cin[3][1] = out[1365];
		temp_cin[4][0] = prev_out[1364];
		temp_cin[4][1] = out[1364];
		temp_cout[0][0] = prev_out[1632];
		or_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1632] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1633:
		temp_cin[0][0] = prev_out[397];
		temp_cin[0][1] = out[397];
		temp_cin[1][0] = prev_out[396];
		temp_cin[1][1] = out[396];
		temp_cin[2][0] = prev_out[476];
		temp_cin[2][1] = out[476];
		temp_cin[3][0] = prev_out[1384];
		temp_cin[3][1] = out[1384];
		temp_cout[0][0] = prev_out[1633];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1633] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1634:
		temp_cin[0][0] = prev_out[396];
		temp_cin[0][1] = out[396];
		temp_cin[1][0] = prev_out[1384];
		temp_cin[1][1] = out[1384];
		temp_cin[2][0] = prev_out[337];
		temp_cin[2][1] = out[337];
		temp_cin[3][0] = prev_out[476];
		temp_cin[3][1] = out[476];
		temp_cout[0][0] = prev_out[1634];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1634] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1635:
		temp_cin[0][0] = prev_out[476];
		temp_cin[0][1] = out[476];
		temp_cin[1][0] = prev_out[1384];
		temp_cin[1][1] = out[1384];
		temp_cin[2][0] = prev_out[402];
		temp_cin[2][1] = out[402];
		temp_cout[0][0] = prev_out[1635];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1635] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1636:
		temp_cin[0][0] = prev_out[1384];
		temp_cin[0][1] = out[1384];
		temp_cin[1][0] = prev_out[539];
		temp_cin[1][1] = out[539];
		temp_cout[0][0] = prev_out[1636];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1636] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1637:
		temp_cin[0][0] = prev_out[929];
		temp_cin[0][1] = out[929];
		temp_cin[1][0] = prev_out[783];
		temp_cin[1][1] = out[783];
		temp_cout[0][0] = prev_out[1637];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1637] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1638:
		temp_cin[0][0] = prev_out[312];
		temp_cin[0][1] = out[312];
		temp_cout[0][0] = prev_out[1638];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1638] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1639:
		temp_cin[0][0] = prev_out[1370];
		temp_cin[0][1] = out[1370];
		temp_cin[1][0] = prev_out[1369];
		temp_cin[1][1] = out[1369];
		temp_cout[0][0] = prev_out[1639];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1639] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1640:
		temp_cin[0][0] = prev_out[1639];
		temp_cin[0][1] = out[1639];
		temp_cout[0][0] = prev_out[1640];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1640] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1641:
		temp_cin[0][0] = prev_out[131];
		temp_cin[0][1] = out[131];
		temp_cin[1][0] = prev_out[133];
		temp_cin[1][1] = out[133];
		temp_cin[2][0] = prev_out[760];
		temp_cin[2][1] = out[760];
		temp_cin[3][0] = prev_out[130];
		temp_cin[3][1] = out[130];
		temp_cin[4][0] = prev_out[312];
		temp_cin[4][1] = out[312];
		temp_cout[0][0] = prev_out[1641];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1641] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1642:
		temp_cin[0][0] = prev_out[133];
		temp_cin[0][1] = out[133];
		temp_cin[1][0] = prev_out[760];
		temp_cin[1][1] = out[760];
		temp_cin[2][0] = prev_out[132];
		temp_cin[2][1] = out[132];
		temp_cin[3][0] = prev_out[312];
		temp_cin[3][1] = out[312];
		temp_cout[0][0] = prev_out[1642];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1642] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1643:
		temp_cin[0][0] = prev_out[312];
		temp_cin[0][1] = out[312];
		temp_cin[1][0] = prev_out[760];
		temp_cin[1][1] = out[760];
		temp_cin[2][0] = prev_out[172];
		temp_cin[2][1] = out[172];
		temp_cout[0][0] = prev_out[1643];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1643] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1644:
		temp_cin[0][0] = prev_out[760];
		temp_cin[0][1] = out[760];
		temp_cin[1][0] = prev_out[378];
		temp_cin[1][1] = out[378];
		temp_cout[0][0] = prev_out[1644];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1644] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1645:
		temp_cin[0][0] = prev_out[620];
		temp_cin[0][1] = out[620];
		temp_cin[1][0] = prev_out[568];
		temp_cin[1][1] = out[568];
		temp_cout[0][0] = prev_out[1645];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1645] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1646:
		temp_cin[0][0] = prev_out[575];
		temp_cin[0][1] = out[575];
		temp_cout[0][0] = prev_out[1646];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1646] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1647:
		temp_cin[0][0] = prev_out[1372];
		temp_cin[0][1] = out[1372];
		temp_cin[1][0] = prev_out[1371];
		temp_cin[1][1] = out[1371];
		temp_cout[0][0] = prev_out[1647];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1647] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1648:
		temp_cin[0][0] = prev_out[1647];
		temp_cin[0][1] = out[1647];
		temp_cout[0][0] = prev_out[1648];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1648] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1649:
		temp_cin[0][0] = prev_out[575];
		temp_cin[0][1] = out[575];
		temp_cout[0][0] = prev_out[1649];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1649] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1650:
		temp_cin[0][0] = prev_out[1374];
		temp_cin[0][1] = out[1374];
		temp_cin[1][0] = prev_out[1373];
		temp_cin[1][1] = out[1373];
		temp_cout[0][0] = prev_out[1650];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1650] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1651:
		temp_cin[0][0] = prev_out[1650];
		temp_cin[0][1] = out[1650];
		temp_cout[0][0] = prev_out[1651];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1651] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1652:
		temp_cin[0][0] = prev_out[1376];
		temp_cin[0][1] = out[1376];
		temp_cin[1][0] = prev_out[1375];
		temp_cin[1][1] = out[1375];
		temp_cout[0][0] = prev_out[1652];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1652] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1653:
		temp_cin[0][0] = prev_out[142];
		temp_cin[0][1] = out[142];
		temp_cin[1][0] = prev_out[1377];
		temp_cin[1][1] = out[1377];
		temp_cout[0][0] = prev_out[1653];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1653] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1654:
		temp_cin[0][0] = prev_out[1379];
		temp_cin[0][1] = out[1379];
		temp_cin[1][0] = prev_out[1378];
		temp_cin[1][1] = out[1378];
		temp_cout[0][0] = prev_out[1654];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1654] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1655:
		temp_cin[0][0] = prev_out[322];
		temp_cin[0][1] = out[322];
		temp_cout[0][0] = prev_out[1655];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1655] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1656:
		temp_cin[0][0] = prev_out[1381];
		temp_cin[0][1] = out[1381];
		temp_cin[1][0] = prev_out[1380];
		temp_cin[1][1] = out[1380];
		temp_cout[0][0] = prev_out[1656];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1656] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1657:
		temp_cin[0][0] = prev_out[1656];
		temp_cin[0][1] = out[1656];
		temp_cout[0][0] = prev_out[1657];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1657] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1658:
		temp_cin[0][0] = prev_out[1384];
		temp_cin[0][1] = out[1384];
		temp_cout[0][0] = prev_out[1658];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1658] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1659:
		temp_cin[0][0] = prev_out[1383];
		temp_cin[0][1] = out[1383];
		temp_cin[1][0] = prev_out[1382];
		temp_cin[1][1] = out[1382];
		temp_cout[0][0] = prev_out[1659];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1659] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1660:
		temp_cin[0][0] = prev_out[1659];
		temp_cin[0][1] = out[1659];
		temp_cout[0][0] = prev_out[1660];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1660] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1661:
		temp_cin[0][0] = prev_out[1384];
		temp_cin[0][1] = out[1384];
		temp_cout[0][0] = prev_out[1661];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1661] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1662:
		temp_cin[0][0] = prev_out[1386];
		temp_cin[0][1] = out[1386];
		temp_cin[1][0] = prev_out[1385];
		temp_cin[1][1] = out[1385];
		temp_cout[0][0] = prev_out[1662];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1662] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1663:
		temp_cin[0][0] = prev_out[1662];
		temp_cin[0][1] = out[1662];
		temp_cout[0][0] = prev_out[1663];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1663] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1664:
		temp_cin[0][0] = prev_out[1388];
		temp_cin[0][1] = out[1388];
		temp_cin[1][0] = prev_out[1387];
		temp_cin[1][1] = out[1387];
		temp_cout[0][0] = prev_out[1664];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1664] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1665:
		temp_cin[0][0] = prev_out[48];
		temp_cin[0][1] = out[48];
		temp_cin[1][0] = prev_out[34];
		temp_cin[1][1] = out[34];
		temp_cout[0][0] = prev_out[1665];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1665] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1666:
		temp_cin[0][0] = prev_out[1390];
		temp_cin[0][1] = out[1390];
		temp_cin[1][0] = prev_out[1389];
		temp_cin[1][1] = out[1389];
		temp_cout[0][0] = prev_out[1666];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1666] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1667:
		temp_cin[0][0] = prev_out[51];
		temp_cin[0][1] = out[51];
		temp_cin[1][0] = prev_out[36];
		temp_cin[1][1] = out[36];
		temp_cout[0][0] = prev_out[1667];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1667] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1668:
		temp_cin[0][0] = prev_out[1392];
		temp_cin[0][1] = out[1392];
		temp_cin[1][0] = prev_out[1391];
		temp_cin[1][1] = out[1391];
		temp_cout[0][0] = prev_out[1668];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1668] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1669:
		temp_cin[0][0] = prev_out[54];
		temp_cin[0][1] = out[54];
		temp_cin[1][0] = prev_out[37];
		temp_cin[1][1] = out[37];
		temp_cout[0][0] = prev_out[1669];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1669] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1670:
		temp_cin[0][0] = prev_out[1394];
		temp_cin[0][1] = out[1394];
		temp_cin[1][0] = prev_out[1393];
		temp_cin[1][1] = out[1393];
		temp_cout[0][0] = prev_out[1670];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1670] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1671:
		temp_cin[0][0] = prev_out[183];
		temp_cin[0][1] = out[183];
		temp_cin[1][0] = prev_out[148];
		temp_cin[1][1] = out[148];
		temp_cout[0][0] = prev_out[1671];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1671] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1672:
		temp_cin[0][0] = prev_out[1396];
		temp_cin[0][1] = out[1396];
		temp_cin[1][0] = prev_out[1395];
		temp_cin[1][1] = out[1395];
		temp_cout[0][0] = prev_out[1672];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1672] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1673:
		temp_cin[0][0] = prev_out[1398];
		temp_cin[0][1] = out[1398];
		temp_cin[1][0] = prev_out[1402];
		temp_cin[1][1] = out[1402];
		temp_cin[2][0] = prev_out[1397];
		temp_cin[2][1] = out[1397];
		temp_cin[3][0] = prev_out[1400];
		temp_cin[3][1] = out[1400];
		temp_cout[0][0] = prev_out[1673];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1673] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1674:
		temp_cin[0][0] = prev_out[1400];
		temp_cin[0][1] = out[1400];
		temp_cin[1][0] = prev_out[1402];
		temp_cin[1][1] = out[1402];
		temp_cin[2][0] = prev_out[1399];
		temp_cin[2][1] = out[1399];
		temp_cout[0][0] = prev_out[1674];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1674] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1675:
		temp_cin[0][0] = prev_out[1402];
		temp_cin[0][1] = out[1402];
		temp_cin[1][0] = prev_out[1401];
		temp_cin[1][1] = out[1401];
		temp_cout[0][0] = prev_out[1675];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1675] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1676:
		temp_cin[0][0] = prev_out[671];
		temp_cin[0][1] = out[671];
		temp_cin[1][0] = prev_out[609];
		temp_cin[1][1] = out[609];
		temp_cout[0][0] = prev_out[1676];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1676] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1677:
		temp_cin[0][0] = prev_out[214];
		temp_cin[0][1] = out[214];
		temp_cout[0][0] = prev_out[1677];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1677] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1678:
		temp_cin[0][0] = prev_out[274];
		temp_cin[0][1] = out[274];
		temp_cout[0][0] = prev_out[1678];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1678] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1679:
		temp_cin[0][0] = prev_out[336];
		temp_cin[0][1] = out[336];
		temp_cout[0][0] = prev_out[1679];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1679] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1680:
		temp_cin[0][0] = prev_out[399];
		temp_cin[0][1] = out[399];
		temp_cout[0][0] = prev_out[1680];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1680] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1681:
		temp_cin[0][0] = prev_out[1403];
		temp_cin[0][1] = out[1403];
		temp_cout[0][0] = prev_out[1681];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1681] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1682:
		temp_cin[0][0] = prev_out[1405];
		temp_cin[0][1] = out[1405];
		temp_cin[1][0] = prev_out[1404];
		temp_cin[1][1] = out[1404];
		temp_cout[0][0] = prev_out[1682];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1682] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1683:
		temp_cin[0][0] = prev_out[1682];
		temp_cin[0][1] = out[1682];
		temp_cout[0][0] = prev_out[1683];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1683] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1684:
		temp_cin[0][0] = prev_out[1407];
		temp_cin[0][1] = out[1407];
		temp_cin[1][0] = prev_out[1406];
		temp_cin[1][1] = out[1406];
		temp_cout[0][0] = prev_out[1684];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1684] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1685:
		temp_cin[0][0] = prev_out[1409];
		temp_cin[0][1] = out[1409];
		temp_cin[1][0] = prev_out[1408];
		temp_cin[1][1] = out[1408];
		temp_cout[0][0] = prev_out[1685];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1685] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1686:
		temp_cin[0][0] = prev_out[1684];
		temp_cin[0][1] = out[1684];
		temp_cout[0][0] = prev_out[1686];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1686] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1687:
		temp_cin[0][0] = prev_out[1411];
		temp_cin[0][1] = out[1411];
		temp_cin[1][0] = prev_out[1410];
		temp_cin[1][1] = out[1410];
		temp_cout[0][0] = prev_out[1687];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1687] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1688:
		temp_cin[0][0] = prev_out[1685];
		temp_cin[0][1] = out[1685];
		temp_cout[0][0] = prev_out[1688];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1688] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1689:
		temp_cin[0][0] = prev_out[1684];
		temp_cin[0][1] = out[1684];
		temp_cout[0][0] = prev_out[1689];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1689] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1690:
		temp_cin[0][0] = prev_out[1687];
		temp_cin[0][1] = out[1687];
		temp_cout[0][0] = prev_out[1690];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1690] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1691:
		temp_cin[0][0] = prev_out[1412];
		temp_cin[0][1] = out[1412];
		temp_cout[0][0] = prev_out[1691];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1691] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1692:
		temp_cin[0][0] = prev_out[1414];
		temp_cin[0][1] = out[1414];
		temp_cin[1][0] = prev_out[1413];
		temp_cin[1][1] = out[1413];
		temp_cout[0][0] = prev_out[1692];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1692] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1693:
		temp_cin[0][0] = prev_out[1692];
		temp_cin[0][1] = out[1692];
		temp_cout[0][0] = prev_out[1693];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1693] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1694:
		temp_cin[0][0] = prev_out[1416];
		temp_cin[0][1] = out[1416];
		temp_cin[1][0] = prev_out[1415];
		temp_cin[1][1] = out[1415];
		temp_cout[0][0] = prev_out[1694];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1694] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1695:
		temp_cin[0][0] = prev_out[1418];
		temp_cin[0][1] = out[1418];
		temp_cin[1][0] = prev_out[1417];
		temp_cin[1][1] = out[1417];
		temp_cout[0][0] = prev_out[1695];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1695] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1696:
		temp_cin[0][0] = prev_out[1694];
		temp_cin[0][1] = out[1694];
		temp_cout[0][0] = prev_out[1696];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1696] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1697:
		temp_cin[0][0] = prev_out[1420];
		temp_cin[0][1] = out[1420];
		temp_cin[1][0] = prev_out[1419];
		temp_cin[1][1] = out[1419];
		temp_cout[0][0] = prev_out[1697];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1697] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1698:
		temp_cin[0][0] = prev_out[1695];
		temp_cin[0][1] = out[1695];
		temp_cout[0][0] = prev_out[1698];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1698] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1699:
		temp_cin[0][0] = prev_out[1694];
		temp_cin[0][1] = out[1694];
		temp_cout[0][0] = prev_out[1699];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1699] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1700:
		temp_cin[0][0] = prev_out[1697];
		temp_cin[0][1] = out[1697];
		temp_cout[0][0] = prev_out[1700];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1700] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1701:
		temp_cin[0][0] = prev_out[1421];
		temp_cin[0][1] = out[1421];
		temp_cout[0][0] = prev_out[1701];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1701] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1702:
		temp_cin[0][0] = prev_out[1423];
		temp_cin[0][1] = out[1423];
		temp_cin[1][0] = prev_out[1422];
		temp_cin[1][1] = out[1422];
		temp_cout[0][0] = prev_out[1702];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1702] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1703:
		temp_cin[0][0] = prev_out[1702];
		temp_cin[0][1] = out[1702];
		temp_cout[0][0] = prev_out[1703];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1703] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1704:
		temp_cin[0][0] = prev_out[1425];
		temp_cin[0][1] = out[1425];
		temp_cin[1][0] = prev_out[1424];
		temp_cin[1][1] = out[1424];
		temp_cout[0][0] = prev_out[1704];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1704] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1705:
		temp_cin[0][0] = prev_out[1427];
		temp_cin[0][1] = out[1427];
		temp_cin[1][0] = prev_out[1426];
		temp_cin[1][1] = out[1426];
		temp_cout[0][0] = prev_out[1705];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1705] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1706:
		temp_cin[0][0] = prev_out[1704];
		temp_cin[0][1] = out[1704];
		temp_cout[0][0] = prev_out[1706];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1706] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1707:
		temp_cin[0][0] = prev_out[1429];
		temp_cin[0][1] = out[1429];
		temp_cin[1][0] = prev_out[1428];
		temp_cin[1][1] = out[1428];
		temp_cout[0][0] = prev_out[1707];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1707] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1708:
		temp_cin[0][0] = prev_out[1705];
		temp_cin[0][1] = out[1705];
		temp_cout[0][0] = prev_out[1708];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1708] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1709:
		temp_cin[0][0] = prev_out[1704];
		temp_cin[0][1] = out[1704];
		temp_cout[0][0] = prev_out[1709];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1709] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1710:
		temp_cin[0][0] = prev_out[1707];
		temp_cin[0][1] = out[1707];
		temp_cout[0][0] = prev_out[1710];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1710] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1711:
		temp_cin[0][0] = prev_out[1430];
		temp_cin[0][1] = out[1430];
		temp_cout[0][0] = prev_out[1711];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1711] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1712:
		temp_cin[0][0] = prev_out[1431];
		temp_cin[0][1] = out[1431];
		temp_cin[1][0] = prev_out[713];
		temp_cin[1][1] = out[713];
		temp_cout[0][0] = prev_out[1712];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1712] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1713:
		temp_cin[0][0] = prev_out[1712];
		temp_cin[0][1] = out[1712];
		temp_cout[0][0] = prev_out[1713];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1713] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1714:
		temp_cin[0][0] = prev_out[1433];
		temp_cin[0][1] = out[1433];
		temp_cin[1][0] = prev_out[1432];
		temp_cin[1][1] = out[1432];
		temp_cout[0][0] = prev_out[1714];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1714] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1715:
		temp_cin[0][0] = prev_out[1435];
		temp_cin[0][1] = out[1435];
		temp_cin[1][0] = prev_out[1434];
		temp_cin[1][1] = out[1434];
		temp_cout[0][0] = prev_out[1715];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1715] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1716:
		temp_cin[0][0] = prev_out[1714];
		temp_cin[0][1] = out[1714];
		temp_cout[0][0] = prev_out[1716];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1716] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1717:
		temp_cin[0][0] = prev_out[1437];
		temp_cin[0][1] = out[1437];
		temp_cin[1][0] = prev_out[1436];
		temp_cin[1][1] = out[1436];
		temp_cout[0][0] = prev_out[1717];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1717] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1718:
		temp_cin[0][0] = prev_out[1715];
		temp_cin[0][1] = out[1715];
		temp_cout[0][0] = prev_out[1718];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1718] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1719:
		temp_cin[0][0] = prev_out[1714];
		temp_cin[0][1] = out[1714];
		temp_cout[0][0] = prev_out[1719];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1719] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1720:
		temp_cin[0][0] = prev_out[1717];
		temp_cin[0][1] = out[1717];
		temp_cout[0][0] = prev_out[1720];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1720] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1721:
		temp_cin[0][0] = prev_out[1438];
		temp_cin[0][1] = out[1438];
		temp_cout[0][0] = prev_out[1721];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1721] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1722:
		temp_cin[0][0] = prev_out[1440];
		temp_cin[0][1] = out[1440];
		temp_cin[1][0] = prev_out[1439];
		temp_cin[1][1] = out[1439];
		temp_cout[0][0] = prev_out[1722];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1722] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1723:
		temp_cin[0][0] = prev_out[1722];
		temp_cin[0][1] = out[1722];
		temp_cout[0][0] = prev_out[1723];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1723] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1724:
		temp_cin[0][0] = prev_out[1442];
		temp_cin[0][1] = out[1442];
		temp_cin[1][0] = prev_out[1441];
		temp_cin[1][1] = out[1441];
		temp_cout[0][0] = prev_out[1724];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1724] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1725:
		temp_cin[0][0] = prev_out[1444];
		temp_cin[0][1] = out[1444];
		temp_cin[1][0] = prev_out[1443];
		temp_cin[1][1] = out[1443];
		temp_cout[0][0] = prev_out[1725];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1725] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1726:
		temp_cin[0][0] = prev_out[1724];
		temp_cin[0][1] = out[1724];
		temp_cout[0][0] = prev_out[1726];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1726] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1727:
		temp_cin[0][0] = prev_out[1446];
		temp_cin[0][1] = out[1446];
		temp_cin[1][0] = prev_out[1445];
		temp_cin[1][1] = out[1445];
		temp_cout[0][0] = prev_out[1727];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1727] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1728:
		temp_cin[0][0] = prev_out[1725];
		temp_cin[0][1] = out[1725];
		temp_cout[0][0] = prev_out[1728];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1728] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1729:
		temp_cin[0][0] = prev_out[1724];
		temp_cin[0][1] = out[1724];
		temp_cout[0][0] = prev_out[1729];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1729] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1730:
		temp_cin[0][0] = prev_out[1727];
		temp_cin[0][1] = out[1727];
		temp_cout[0][0] = prev_out[1730];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1730] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1731:
		temp_cin[0][0] = prev_out[1447];
		temp_cin[0][1] = out[1447];
		temp_cout[0][0] = prev_out[1731];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1731] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1732:
		temp_cin[0][0] = prev_out[1449];
		temp_cin[0][1] = out[1449];
		temp_cin[1][0] = prev_out[1448];
		temp_cin[1][1] = out[1448];
		temp_cout[0][0] = prev_out[1732];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1732] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1733:
		temp_cin[0][0] = prev_out[1732];
		temp_cin[0][1] = out[1732];
		temp_cout[0][0] = prev_out[1733];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1733] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1734:
		temp_cin[0][0] = prev_out[1451];
		temp_cin[0][1] = out[1451];
		temp_cin[1][0] = prev_out[1450];
		temp_cin[1][1] = out[1450];
		temp_cout[0][0] = prev_out[1734];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1734] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1735:
		temp_cin[0][0] = prev_out[1453];
		temp_cin[0][1] = out[1453];
		temp_cin[1][0] = prev_out[1452];
		temp_cin[1][1] = out[1452];
		temp_cout[0][0] = prev_out[1735];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1735] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1736:
		temp_cin[0][0] = prev_out[1734];
		temp_cin[0][1] = out[1734];
		temp_cout[0][0] = prev_out[1736];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1736] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1737:
		temp_cin[0][0] = prev_out[1455];
		temp_cin[0][1] = out[1455];
		temp_cin[1][0] = prev_out[1454];
		temp_cin[1][1] = out[1454];
		temp_cout[0][0] = prev_out[1737];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1737] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1738:
		temp_cin[0][0] = prev_out[1735];
		temp_cin[0][1] = out[1735];
		temp_cout[0][0] = prev_out[1738];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1738] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1739:
		temp_cin[0][0] = prev_out[1734];
		temp_cin[0][1] = out[1734];
		temp_cout[0][0] = prev_out[1739];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1739] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1740:
		temp_cin[0][0] = prev_out[1737];
		temp_cin[0][1] = out[1737];
		temp_cout[0][0] = prev_out[1740];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1740] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1741:
		temp_cin[0][0] = prev_out[1456];
		temp_cin[0][1] = out[1456];
		temp_cout[0][0] = prev_out[1741];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1741] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1742:
		temp_cin[0][0] = prev_out[1458];
		temp_cin[0][1] = out[1458];
		temp_cin[1][0] = prev_out[1457];
		temp_cin[1][1] = out[1457];
		temp_cout[0][0] = prev_out[1742];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1742] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1743:
		temp_cin[0][0] = prev_out[1742];
		temp_cin[0][1] = out[1742];
		temp_cout[0][0] = prev_out[1743];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1743] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1744:
		temp_cin[0][0] = prev_out[1460];
		temp_cin[0][1] = out[1460];
		temp_cin[1][0] = prev_out[1459];
		temp_cin[1][1] = out[1459];
		temp_cout[0][0] = prev_out[1744];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1744] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1745:
		temp_cin[0][0] = prev_out[1462];
		temp_cin[0][1] = out[1462];
		temp_cin[1][0] = prev_out[1461];
		temp_cin[1][1] = out[1461];
		temp_cout[0][0] = prev_out[1745];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1745] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1746:
		temp_cin[0][0] = prev_out[1744];
		temp_cin[0][1] = out[1744];
		temp_cout[0][0] = prev_out[1746];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1746] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1747:
		temp_cin[0][0] = prev_out[1464];
		temp_cin[0][1] = out[1464];
		temp_cin[1][0] = prev_out[1463];
		temp_cin[1][1] = out[1463];
		temp_cout[0][0] = prev_out[1747];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1747] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1748:
		temp_cin[0][0] = prev_out[1745];
		temp_cin[0][1] = out[1745];
		temp_cout[0][0] = prev_out[1748];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1748] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1749:
		temp_cin[0][0] = prev_out[1744];
		temp_cin[0][1] = out[1744];
		temp_cout[0][0] = prev_out[1749];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1749] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1750:
		temp_cin[0][0] = prev_out[1747];
		temp_cin[0][1] = out[1747];
		temp_cout[0][0] = prev_out[1750];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1750] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1751:
		temp_cin[0][0] = prev_out[1465];
		temp_cin[0][1] = out[1465];
		temp_cout[0][0] = prev_out[1751];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1751] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1752:
		temp_cin[0][0] = prev_out[1467];
		temp_cin[0][1] = out[1467];
		temp_cin[1][0] = prev_out[1466];
		temp_cin[1][1] = out[1466];
		temp_cout[0][0] = prev_out[1752];
		or_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1752] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1753:
		temp_cin[0][0] = prev_out[1752];
		temp_cin[0][1] = out[1752];
		temp_cout[0][0] = prev_out[1753];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1753] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1754:
		temp_cin[0][0] = prev_out[1469];
		temp_cin[0][1] = out[1469];
		temp_cin[1][0] = prev_out[1468];
		temp_cin[1][1] = out[1468];
		temp_cout[0][0] = prev_out[1754];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1754] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1755:
		temp_cin[0][0] = prev_out[1471];
		temp_cin[0][1] = out[1471];
		temp_cin[1][0] = prev_out[1470];
		temp_cin[1][1] = out[1470];
		temp_cout[0][0] = prev_out[1755];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1755] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1756:
		temp_cin[0][0] = prev_out[1754];
		temp_cin[0][1] = out[1754];
		temp_cout[0][0] = prev_out[1756];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1756] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1757:
		temp_cin[0][0] = prev_out[1473];
		temp_cin[0][1] = out[1473];
		temp_cin[1][0] = prev_out[1472];
		temp_cin[1][1] = out[1472];
		temp_cout[0][0] = prev_out[1757];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1757] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1758:
		temp_cin[0][0] = prev_out[1755];
		temp_cin[0][1] = out[1755];
		temp_cout[0][0] = prev_out[1758];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1758] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1759:
		temp_cin[0][0] = prev_out[1754];
		temp_cin[0][1] = out[1754];
		temp_cout[0][0] = prev_out[1759];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1759] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1760:
		temp_cin[0][0] = prev_out[1757];
		temp_cin[0][1] = out[1757];
		temp_cout[0][0] = prev_out[1760];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1760] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1761:
		temp_cin[0][0] = prev_out[1474];
		temp_cin[0][1] = out[1474];
		temp_cout[0][0] = prev_out[1761];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1761] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1762:
		temp_cin[0][0] = prev_out[1476];
		temp_cin[0][1] = out[1476];
		temp_cin[1][0] = prev_out[1475];
		temp_cin[1][1] = out[1475];
		temp_cout[0][0] = prev_out[1762];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1762] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1763:
		temp_cin[0][0] = prev_out[1762];
		temp_cin[0][1] = out[1762];
		temp_cout[0][0] = prev_out[1763];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1763] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1764:
		temp_cin[0][0] = prev_out[1478];
		temp_cin[0][1] = out[1478];
		temp_cin[1][0] = prev_out[1477];
		temp_cin[1][1] = out[1477];
		temp_cout[0][0] = prev_out[1764];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1764] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1765:
		temp_cin[0][0] = prev_out[1480];
		temp_cin[0][1] = out[1480];
		temp_cin[1][0] = prev_out[1479];
		temp_cin[1][1] = out[1479];
		temp_cout[0][0] = prev_out[1765];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1765] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1766:
		temp_cin[0][0] = prev_out[1764];
		temp_cin[0][1] = out[1764];
		temp_cout[0][0] = prev_out[1766];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1766] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1767:
		temp_cin[0][0] = prev_out[1482];
		temp_cin[0][1] = out[1482];
		temp_cin[1][0] = prev_out[1481];
		temp_cin[1][1] = out[1481];
		temp_cout[0][0] = prev_out[1767];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1767] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1768:
		temp_cin[0][0] = prev_out[1765];
		temp_cin[0][1] = out[1765];
		temp_cout[0][0] = prev_out[1768];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1768] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1769:
		temp_cin[0][0] = prev_out[1764];
		temp_cin[0][1] = out[1764];
		temp_cout[0][0] = prev_out[1769];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1769] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1770:
		temp_cin[0][0] = prev_out[1767];
		temp_cin[0][1] = out[1767];
		temp_cout[0][0] = prev_out[1770];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1770] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1771:
		temp_cin[0][0] = prev_out[1483];
		temp_cin[0][1] = out[1483];
		temp_cout[0][0] = prev_out[1771];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1771] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1772:
		temp_cin[0][0] = prev_out[1485];
		temp_cin[0][1] = out[1485];
		temp_cin[1][0] = prev_out[1484];
		temp_cin[1][1] = out[1484];
		temp_cout[0][0] = prev_out[1772];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1772] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1773:
		temp_cin[0][0] = prev_out[1772];
		temp_cin[0][1] = out[1772];
		temp_cout[0][0] = prev_out[1773];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1773] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1774:
		temp_cin[0][0] = prev_out[1487];
		temp_cin[0][1] = out[1487];
		temp_cin[1][0] = prev_out[1486];
		temp_cin[1][1] = out[1486];
		temp_cout[0][0] = prev_out[1774];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1774] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1775:
		temp_cin[0][0] = prev_out[1489];
		temp_cin[0][1] = out[1489];
		temp_cin[1][0] = prev_out[1488];
		temp_cin[1][1] = out[1488];
		temp_cout[0][0] = prev_out[1775];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1775] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1776:
		temp_cin[0][0] = prev_out[1774];
		temp_cin[0][1] = out[1774];
		temp_cout[0][0] = prev_out[1776];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1776] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1777:
		temp_cin[0][0] = prev_out[1491];
		temp_cin[0][1] = out[1491];
		temp_cin[1][0] = prev_out[1490];
		temp_cin[1][1] = out[1490];
		temp_cout[0][0] = prev_out[1777];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1777] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1778:
		temp_cin[0][0] = prev_out[1775];
		temp_cin[0][1] = out[1775];
		temp_cout[0][0] = prev_out[1778];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1778] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1779:
		temp_cin[0][0] = prev_out[1774];
		temp_cin[0][1] = out[1774];
		temp_cout[0][0] = prev_out[1779];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1779] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1780:
		temp_cin[0][0] = prev_out[1777];
		temp_cin[0][1] = out[1777];
		temp_cout[0][0] = prev_out[1780];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1780] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1781:
		temp_cin[0][0] = prev_out[1492];
		temp_cin[0][1] = out[1492];
		temp_cout[0][0] = prev_out[1781];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1781] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1782:
		temp_cin[0][0] = prev_out[1494];
		temp_cin[0][1] = out[1494];
		temp_cin[1][0] = prev_out[1493];
		temp_cin[1][1] = out[1493];
		temp_cout[0][0] = prev_out[1782];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1782] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1783:
		temp_cin[0][0] = prev_out[1782];
		temp_cin[0][1] = out[1782];
		temp_cout[0][0] = prev_out[1783];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1783] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1784:
		temp_cin[0][0] = prev_out[1496];
		temp_cin[0][1] = out[1496];
		temp_cin[1][0] = prev_out[1495];
		temp_cin[1][1] = out[1495];
		temp_cout[0][0] = prev_out[1784];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1784] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1785:
		temp_cin[0][0] = prev_out[1498];
		temp_cin[0][1] = out[1498];
		temp_cin[1][0] = prev_out[1497];
		temp_cin[1][1] = out[1497];
		temp_cout[0][0] = prev_out[1785];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1785] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1786:
		temp_cin[0][0] = prev_out[1784];
		temp_cin[0][1] = out[1784];
		temp_cout[0][0] = prev_out[1786];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1786] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1787:
		temp_cin[0][0] = prev_out[1500];
		temp_cin[0][1] = out[1500];
		temp_cin[1][0] = prev_out[1499];
		temp_cin[1][1] = out[1499];
		temp_cout[0][0] = prev_out[1787];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1787] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1788:
		temp_cin[0][0] = prev_out[1785];
		temp_cin[0][1] = out[1785];
		temp_cout[0][0] = prev_out[1788];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1788] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1789:
		temp_cin[0][0] = prev_out[1784];
		temp_cin[0][1] = out[1784];
		temp_cout[0][0] = prev_out[1789];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1789] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1790:
		temp_cin[0][0] = prev_out[1787];
		temp_cin[0][1] = out[1787];
		temp_cout[0][0] = prev_out[1790];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1790] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1791:
		temp_cin[0][0] = prev_out[1501];
		temp_cin[0][1] = out[1501];
		temp_cout[0][0] = prev_out[1791];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1791] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1792:
		temp_cin[0][0] = prev_out[1502];
		temp_cin[0][1] = out[1502];
		temp_cin[1][0] = prev_out[26];
		temp_cin[1][1] = out[26];
		temp_cout[0][0] = prev_out[1792];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1792] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1793:
		temp_cin[0][0] = prev_out[1792];
		temp_cin[0][1] = out[1792];
		temp_cout[0][0] = prev_out[1793];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1793] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1794:
		temp_cin[0][0] = prev_out[1504];
		temp_cin[0][1] = out[1504];
		temp_cin[1][0] = prev_out[1503];
		temp_cin[1][1] = out[1503];
		temp_cout[0][0] = prev_out[1794];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1794] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1795:
		temp_cin[0][0] = prev_out[1506];
		temp_cin[0][1] = out[1506];
		temp_cin[1][0] = prev_out[1505];
		temp_cin[1][1] = out[1505];
		temp_cout[0][0] = prev_out[1795];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1795] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1796:
		temp_cin[0][0] = prev_out[1794];
		temp_cin[0][1] = out[1794];
		temp_cout[0][0] = prev_out[1796];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1796] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1797:
		temp_cin[0][0] = prev_out[1508];
		temp_cin[0][1] = out[1508];
		temp_cin[1][0] = prev_out[1507];
		temp_cin[1][1] = out[1507];
		temp_cout[0][0] = prev_out[1797];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1797] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1798:
		temp_cin[0][0] = prev_out[1795];
		temp_cin[0][1] = out[1795];
		temp_cout[0][0] = prev_out[1798];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1798] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1799:
		temp_cin[0][0] = prev_out[1794];
		temp_cin[0][1] = out[1794];
		temp_cout[0][0] = prev_out[1799];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1799] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1800:
		temp_cin[0][0] = prev_out[1797];
		temp_cin[0][1] = out[1797];
		temp_cout[0][0] = prev_out[1800];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1800] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1801:
		temp_cin[0][0] = prev_out[78];
		temp_cin[0][1] = out[78];
		temp_cin[1][0] = prev_out[1509];
		temp_cin[1][1] = out[1509];
		temp_cout[0][0] = prev_out[1801];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1801] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1802:
		temp_cin[0][0] = prev_out[45];
		temp_cin[0][1] = out[45];
		temp_cin[1][0] = prev_out[1510];
		temp_cin[1][1] = out[1510];
		temp_cout[0][0] = prev_out[1802];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1802] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1803:
		temp_cin[0][0] = prev_out[630];
		temp_cin[0][1] = out[630];
		temp_cin[1][0] = prev_out[1511];
		temp_cin[1][1] = out[1511];
		temp_cout[0][0] = prev_out[1803];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1803] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1804:
		temp_cin[0][0] = prev_out[578];
		temp_cin[0][1] = out[578];
		temp_cin[1][0] = prev_out[1512];
		temp_cin[1][1] = out[1512];
		temp_cout[0][0] = prev_out[1804];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1804] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1805:
		temp_cin[0][0] = prev_out[81];
		temp_cin[0][1] = out[81];
		temp_cin[1][0] = prev_out[1513];
		temp_cin[1][1] = out[1513];
		temp_cout[0][0] = prev_out[1805];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1805] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1806:
		temp_cin[0][0] = prev_out[46];
		temp_cin[0][1] = out[46];
		temp_cin[1][0] = prev_out[1514];
		temp_cin[1][1] = out[1514];
		temp_cout[0][0] = prev_out[1806];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1806] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1807:
		temp_cin[0][0] = prev_out[75];
		temp_cin[0][1] = out[75];
		temp_cin[1][0] = prev_out[1515];
		temp_cin[1][1] = out[1515];
		temp_cout[0][0] = prev_out[1807];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1807] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1808:
		temp_cin[0][0] = prev_out[44];
		temp_cin[0][1] = out[44];
		temp_cin[1][0] = prev_out[1516];
		temp_cin[1][1] = out[1516];
		temp_cout[0][0] = prev_out[1808];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1808] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1809:
		temp_cin[0][0] = prev_out[208];
		temp_cin[0][1] = out[208];
		temp_cin[1][0] = prev_out[1517];
		temp_cin[1][1] = out[1517];
		temp_cout[0][0] = prev_out[1809];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1809] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1810:
		temp_cin[0][0] = prev_out[174];
		temp_cin[0][1] = out[174];
		temp_cin[1][0] = prev_out[1518];
		temp_cin[1][1] = out[1518];
		temp_cout[0][0] = prev_out[1810];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1810] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1811:
		temp_cin[0][0] = prev_out[1520];
		temp_cin[0][1] = out[1520];
		temp_cin[1][0] = prev_out[1519];
		temp_cin[1][1] = out[1519];
		temp_cout[0][0] = prev_out[1811];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1811] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1812:
		temp_cin[0][0] = prev_out[1522];
		temp_cin[0][1] = out[1522];
		temp_cin[1][0] = prev_out[1524];
		temp_cin[1][1] = out[1524];
		temp_cin[2][0] = prev_out[1528];
		temp_cin[2][1] = out[1528];
		temp_cin[3][0] = prev_out[1521];
		temp_cin[3][1] = out[1521];
		temp_cin[4][0] = prev_out[1526];
		temp_cin[4][1] = out[1526];
		temp_cout[0][0] = prev_out[1812];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1812] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1813:
		temp_cin[0][0] = prev_out[1524];
		temp_cin[0][1] = out[1524];
		temp_cin[1][0] = prev_out[1528];
		temp_cin[1][1] = out[1528];
		temp_cin[2][0] = prev_out[1523];
		temp_cin[2][1] = out[1523];
		temp_cin[3][0] = prev_out[1526];
		temp_cin[3][1] = out[1526];
		temp_cout[0][0] = prev_out[1813];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1813] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1814:
		temp_cin[0][0] = prev_out[1526];
		temp_cin[0][1] = out[1526];
		temp_cin[1][0] = prev_out[1528];
		temp_cin[1][1] = out[1528];
		temp_cin[2][0] = prev_out[1525];
		temp_cin[2][1] = out[1525];
		temp_cout[0][0] = prev_out[1814];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1814] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1815:
		temp_cin[0][0] = prev_out[1528];
		temp_cin[0][1] = out[1528];
		temp_cin[1][0] = prev_out[1527];
		temp_cin[1][1] = out[1527];
		temp_cout[0][0] = prev_out[1815];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1815] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1816:
		temp_cin[0][0] = prev_out[605];
		temp_cin[0][1] = out[605];
		temp_cin[1][0] = prev_out[554];
		temp_cin[1][1] = out[554];
		temp_cout[0][0] = prev_out[1816];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1816] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1817:
		temp_cin[0][0] = prev_out[199];
		temp_cin[0][1] = out[199];
		temp_cin[1][0] = prev_out[249];
		temp_cin[1][1] = out[249];
		temp_cout[0][0] = prev_out[1817];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1817] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1818:
		temp_cin[0][0] = prev_out[1530];
		temp_cin[0][1] = out[1530];
		temp_cin[1][0] = prev_out[1529];
		temp_cin[1][1] = out[1529];
		temp_cout[0][0] = prev_out[1818];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1818] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1819:
		temp_cin[0][0] = prev_out[246];
		temp_cin[0][1] = out[246];
		temp_cin[1][0] = prev_out[198];
		temp_cin[1][1] = out[198];
		temp_cout[0][0] = prev_out[1819];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1819] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1820:
		temp_cin[0][0] = prev_out[1532];
		temp_cin[0][1] = out[1532];
		temp_cin[1][0] = prev_out[1531];
		temp_cin[1][1] = out[1531];
		temp_cout[0][0] = prev_out[1820];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1820] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1821:
		temp_cin[0][0] = prev_out[370];
		temp_cin[0][1] = out[370];
		temp_cin[1][0] = prev_out[310];
		temp_cin[1][1] = out[310];
		temp_cout[0][0] = prev_out[1821];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1821] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1822:
		temp_cin[0][0] = prev_out[1534];
		temp_cin[0][1] = out[1534];
		temp_cin[1][0] = prev_out[1533];
		temp_cin[1][1] = out[1533];
		temp_cout[0][0] = prev_out[1822];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1822] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1823:
		temp_cin[0][0] = prev_out[277];
		temp_cin[0][1] = out[277];
		temp_cin[1][0] = prev_out[1535];
		temp_cin[1][1] = out[1535];
		temp_cout[0][0] = prev_out[1823];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1823] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1824:
		temp_cin[0][0] = prev_out[215];
		temp_cin[0][1] = out[215];
		temp_cin[1][0] = prev_out[1536];
		temp_cin[1][1] = out[1536];
		temp_cout[0][0] = prev_out[1824];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1824] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1825:
		temp_cin[0][0] = prev_out[75];
		temp_cin[0][1] = out[75];
		temp_cin[1][0] = prev_out[44];
		temp_cin[1][1] = out[44];
		temp_cout[0][0] = prev_out[1825];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1825] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1826:
		temp_cin[0][0] = prev_out[78];
		temp_cin[0][1] = out[78];
		temp_cin[1][0] = prev_out[45];
		temp_cin[1][1] = out[45];
		temp_cout[0][0] = prev_out[1826];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1826] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1827:
		temp_cin[0][0] = prev_out[81];
		temp_cin[0][1] = out[81];
		temp_cin[1][0] = prev_out[46];
		temp_cin[1][1] = out[46];
		temp_cout[0][0] = prev_out[1827];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1827] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1828:
		temp_cin[0][0] = prev_out[208];
		temp_cin[0][1] = out[208];
		temp_cin[1][0] = prev_out[174];
		temp_cin[1][1] = out[174];
		temp_cout[0][0] = prev_out[1828];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1828] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1829:
		temp_cin[0][0] = prev_out[929];
		temp_cin[0][1] = out[929];
		temp_cin[1][0] = prev_out[1537];
		temp_cin[1][1] = out[1537];
		temp_cout[0][0] = prev_out[1829];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1829] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1830:
		temp_cin[0][0] = prev_out[783];
		temp_cin[0][1] = out[783];
		temp_cin[1][0] = prev_out[1538];
		temp_cin[1][1] = out[1538];
		temp_cout[0][0] = prev_out[1830];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1830] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1831:
		temp_cin[0][0] = prev_out[57];
		temp_cin[0][1] = out[57];
		temp_cin[1][0] = prev_out[1539];
		temp_cin[1][1] = out[1539];
		temp_cout[0][0] = prev_out[1831];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1831] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1832:
		temp_cin[0][0] = prev_out[38];
		temp_cin[0][1] = out[38];
		temp_cin[1][0] = prev_out[1540];
		temp_cin[1][1] = out[1540];
		temp_cout[0][0] = prev_out[1832];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1832] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1833:
		temp_cin[0][0] = prev_out[1542];
		temp_cin[0][1] = out[1542];
		temp_cin[1][0] = prev_out[1541];
		temp_cin[1][1] = out[1541];
		temp_cout[0][0] = prev_out[1833];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1833] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1834:
		temp_cin[0][0] = prev_out[1544];
		temp_cin[0][1] = out[1544];
		temp_cin[1][0] = prev_out[1543];
		temp_cin[1][1] = out[1543];
		temp_cout[0][0] = prev_out[1834];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1834] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1835:
		temp_cin[0][0] = prev_out[1546];
		temp_cin[0][1] = out[1546];
		temp_cin[1][0] = prev_out[1545];
		temp_cin[1][1] = out[1545];
		temp_cout[0][0] = prev_out[1835];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1835] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1836:
		temp_cin[0][0] = prev_out[1548];
		temp_cin[0][1] = out[1548];
		temp_cin[1][0] = prev_out[1547];
		temp_cin[1][1] = out[1547];
		temp_cout[0][0] = prev_out[1836];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1836] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1837:
		temp_cin[0][0] = prev_out[1550];
		temp_cin[0][1] = out[1550];
		temp_cin[1][0] = prev_out[1549];
		temp_cin[1][1] = out[1549];
		temp_cout[0][0] = prev_out[1837];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1837] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1838:
		temp_cin[0][0] = prev_out[1552];
		temp_cin[0][1] = out[1552];
		temp_cin[1][0] = prev_out[1551];
		temp_cin[1][1] = out[1551];
		temp_cout[0][0] = prev_out[1838];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1838] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1839:
		temp_cin[0][0] = prev_out[1554];
		temp_cin[0][1] = out[1554];
		temp_cin[1][0] = prev_out[1558];
		temp_cin[1][1] = out[1558];
		temp_cin[2][0] = prev_out[1553];
		temp_cin[2][1] = out[1553];
		temp_cin[3][0] = prev_out[1556];
		temp_cin[3][1] = out[1556];
		temp_cout[0][0] = prev_out[1839];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1839] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1840:
		temp_cin[0][0] = prev_out[1556];
		temp_cin[0][1] = out[1556];
		temp_cin[1][0] = prev_out[1558];
		temp_cin[1][1] = out[1558];
		temp_cin[2][0] = prev_out[1555];
		temp_cin[2][1] = out[1555];
		temp_cout[0][0] = prev_out[1840];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1840] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1841:
		temp_cin[0][0] = prev_out[1558];
		temp_cin[0][1] = out[1558];
		temp_cin[1][0] = prev_out[1557];
		temp_cin[1][1] = out[1557];
		temp_cout[0][0] = prev_out[1841];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1841] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1842:
		temp_cin[0][0] = prev_out[1059];
		temp_cin[0][1] = out[1059];
		temp_cin[1][0] = prev_out[943];
		temp_cin[1][1] = out[943];
		temp_cout[0][0] = prev_out[1842];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1842] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1843:
		temp_cin[0][0] = prev_out[1221];
		temp_cin[0][1] = out[1221];
		temp_cin[1][0] = prev_out[1559];
		temp_cin[1][1] = out[1559];
		temp_cout[0][0] = prev_out[1843];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1843] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1844:
		temp_cin[0][0] = prev_out[1171];
		temp_cin[0][1] = out[1171];
		temp_cin[1][0] = prev_out[1560];
		temp_cin[1][1] = out[1560];
		temp_cout[0][0] = prev_out[1844];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1844] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1845:
		temp_cin[0][0] = prev_out[1216];
		temp_cin[0][1] = out[1216];
		temp_cin[1][0] = prev_out[1561];
		temp_cin[1][1] = out[1561];
		temp_cout[0][0] = prev_out[1845];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1845] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1846:
		temp_cin[0][0] = prev_out[1166];
		temp_cin[0][1] = out[1166];
		temp_cin[1][0] = prev_out[1562];
		temp_cin[1][1] = out[1562];
		temp_cout[0][0] = prev_out[1846];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1846] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1847:
		temp_cin[0][0] = prev_out[997];
		temp_cin[0][1] = out[997];
		temp_cin[1][0] = prev_out[1563];
		temp_cin[1][1] = out[1563];
		temp_cout[0][0] = prev_out[1847];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1847] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1848:
		temp_cin[0][0] = prev_out[953];
		temp_cin[0][1] = out[953];
		temp_cin[1][0] = prev_out[1564];
		temp_cin[1][1] = out[1564];
		temp_cout[0][0] = prev_out[1848];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1848] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1849:
		temp_cin[0][0] = prev_out[995];
		temp_cin[0][1] = out[995];
		temp_cin[1][0] = prev_out[1565];
		temp_cin[1][1] = out[1565];
		temp_cout[0][0] = prev_out[1849];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1849] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1850:
		temp_cin[0][0] = prev_out[951];
		temp_cin[0][1] = out[951];
		temp_cin[1][0] = prev_out[1566];
		temp_cin[1][1] = out[1566];
		temp_cout[0][0] = prev_out[1850];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1850] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1851:
		temp_cin[0][0] = prev_out[834];
		temp_cin[0][1] = out[834];
		temp_cin[1][0] = prev_out[1567];
		temp_cin[1][1] = out[1567];
		temp_cout[0][0] = prev_out[1851];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1851] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1852:
		temp_cin[0][0] = prev_out[798];
		temp_cin[0][1] = out[798];
		temp_cin[1][0] = prev_out[1568];
		temp_cin[1][1] = out[1568];
		temp_cout[0][0] = prev_out[1852];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1852] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1853:
		temp_cin[0][0] = prev_out[1837];
		temp_cin[0][1] = out[1837];
		temp_cin[1][0] = prev_out[1836];
		temp_cin[1][1] = out[1836];
		temp_cin[2][0] = prev_out[1834];
		temp_cin[2][1] = out[1834];
		temp_cin[3][0] = prev_out[1569];
		temp_cin[3][1] = out[1569];
		temp_cin[4][0] = prev_out[1835];
		temp_cin[4][1] = out[1835];
		temp_cout[0][0] = prev_out[1853];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1853] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1854:
		temp_cin[0][0] = prev_out[1836];
		temp_cin[0][1] = out[1836];
		temp_cin[1][0] = prev_out[1834];
		temp_cin[1][1] = out[1834];
		temp_cin[2][0] = prev_out[1570];
		temp_cin[2][1] = out[1570];
		temp_cin[3][0] = prev_out[1835];
		temp_cin[3][1] = out[1835];
		temp_cout[0][0] = prev_out[1854];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1854] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1855:
		temp_cin[0][0] = prev_out[1835];
		temp_cin[0][1] = out[1835];
		temp_cin[1][0] = prev_out[1834];
		temp_cin[1][1] = out[1834];
		temp_cin[2][0] = prev_out[1571];
		temp_cin[2][1] = out[1571];
		temp_cout[0][0] = prev_out[1855];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1855] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1856:
		temp_cin[0][0] = prev_out[1834];
		temp_cin[0][1] = out[1834];
		temp_cin[1][0] = prev_out[1572];
		temp_cin[1][1] = out[1572];
		temp_cout[0][0] = prev_out[1856];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1856] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1857:
		temp_cin[0][0] = prev_out[1205];
		temp_cin[0][1] = out[1205];
		temp_cin[1][0] = prev_out[1156];
		temp_cin[1][1] = out[1156];
		temp_cout[0][0] = prev_out[1857];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1857] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1858:
		temp_cin[0][0] = prev_out[1574];
		temp_cin[0][1] = out[1574];
		temp_cin[1][0] = prev_out[1573];
		temp_cin[1][1] = out[1573];
		temp_cout[0][0] = prev_out[1858];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1858] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1859:
		temp_cin[0][0] = prev_out[1231];
		temp_cin[0][1] = out[1231];
		temp_cin[1][0] = prev_out[1575];
		temp_cin[1][1] = out[1575];
		temp_cout[0][0] = prev_out[1859];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1859] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1860:
		temp_cin[0][0] = prev_out[1181];
		temp_cin[0][1] = out[1181];
		temp_cin[1][0] = prev_out[1576];
		temp_cin[1][1] = out[1576];
		temp_cout[0][0] = prev_out[1860];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1860] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1861:
		temp_cin[0][0] = prev_out[1009];
		temp_cin[0][1] = out[1009];
		temp_cin[1][0] = prev_out[1577];
		temp_cin[1][1] = out[1577];
		temp_cout[0][0] = prev_out[1861];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1861] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1862:
		temp_cin[0][0] = prev_out[968];
		temp_cin[0][1] = out[968];
		temp_cin[1][0] = prev_out[1578];
		temp_cin[1][1] = out[1578];
		temp_cout[0][0] = prev_out[1862];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1862] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1863:
		temp_cin[0][0] = prev_out[1237];
		temp_cin[0][1] = out[1237];
		temp_cin[1][0] = prev_out[1579];
		temp_cin[1][1] = out[1579];
		temp_cout[0][0] = prev_out[1863];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1863] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1864:
		temp_cin[0][0] = prev_out[1187];
		temp_cin[0][1] = out[1187];
		temp_cin[1][0] = prev_out[1580];
		temp_cin[1][1] = out[1580];
		temp_cout[0][0] = prev_out[1864];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1864] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1865:
		temp_cin[0][0] = prev_out[1015];
		temp_cin[0][1] = out[1015];
		temp_cin[1][0] = prev_out[1581];
		temp_cin[1][1] = out[1581];
		temp_cout[0][0] = prev_out[1865];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1865] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1866:
		temp_cin[0][0] = prev_out[973];
		temp_cin[0][1] = out[973];
		temp_cin[1][0] = prev_out[1582];
		temp_cin[1][1] = out[1582];
		temp_cout[0][0] = prev_out[1866];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1866] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1867:
		temp_cin[0][0] = prev_out[1234];
		temp_cin[0][1] = out[1234];
		temp_cin[1][0] = prev_out[1583];
		temp_cin[1][1] = out[1583];
		temp_cout[0][0] = prev_out[1867];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1867] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1868:
		temp_cin[0][0] = prev_out[1184];
		temp_cin[0][1] = out[1184];
		temp_cin[1][0] = prev_out[1584];
		temp_cin[1][1] = out[1584];
		temp_cout[0][0] = prev_out[1868];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1868] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1869:
		temp_cin[0][0] = prev_out[1586];
		temp_cin[0][1] = out[1586];
		temp_cin[1][0] = prev_out[1588];
		temp_cin[1][1] = out[1588];
		temp_cin[2][0] = prev_out[1592];
		temp_cin[2][1] = out[1592];
		temp_cin[3][0] = prev_out[1585];
		temp_cin[3][1] = out[1585];
		temp_cin[4][0] = prev_out[1590];
		temp_cin[4][1] = out[1590];
		temp_cout[0][0] = prev_out[1869];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1869] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1870:
		temp_cin[0][0] = prev_out[1588];
		temp_cin[0][1] = out[1588];
		temp_cin[1][0] = prev_out[1592];
		temp_cin[1][1] = out[1592];
		temp_cin[2][0] = prev_out[1587];
		temp_cin[2][1] = out[1587];
		temp_cin[3][0] = prev_out[1590];
		temp_cin[3][1] = out[1590];
		temp_cout[0][0] = prev_out[1870];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1870] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1871:
		temp_cin[0][0] = prev_out[1590];
		temp_cin[0][1] = out[1590];
		temp_cin[1][0] = prev_out[1592];
		temp_cin[1][1] = out[1592];
		temp_cin[2][0] = prev_out[1589];
		temp_cin[2][1] = out[1589];
		temp_cout[0][0] = prev_out[1871];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1871] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1872:
		temp_cin[0][0] = prev_out[1592];
		temp_cin[0][1] = out[1592];
		temp_cin[1][0] = prev_out[1591];
		temp_cin[1][1] = out[1591];
		temp_cout[0][0] = prev_out[1872];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1872] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1873:
		temp_cin[0][0] = prev_out[1071];
		temp_cin[0][1] = out[1071];
		temp_cin[1][0] = prev_out[957];
		temp_cin[1][1] = out[957];
		temp_cout[0][0] = prev_out[1873];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1873] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1874:
		temp_cin[0][0] = prev_out[834];
		temp_cin[0][1] = out[834];
		temp_cin[1][0] = prev_out[798];
		temp_cin[1][1] = out[798];
		temp_cout[0][0] = prev_out[1874];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1874] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1875:
		temp_cin[0][0] = prev_out[995];
		temp_cin[0][1] = out[995];
		temp_cin[1][0] = prev_out[951];
		temp_cin[1][1] = out[951];
		temp_cout[0][0] = prev_out[1875];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1875] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1876:
		temp_cin[0][0] = prev_out[997];
		temp_cin[0][1] = out[997];
		temp_cin[1][0] = prev_out[953];
		temp_cin[1][1] = out[953];
		temp_cout[0][0] = prev_out[1876];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1876] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1877:
		temp_cin[0][0] = prev_out[1234];
		temp_cin[0][1] = out[1234];
		temp_cin[1][0] = prev_out[1184];
		temp_cin[1][1] = out[1184];
		temp_cout[0][0] = prev_out[1877];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1877] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1878:
		temp_cin[0][0] = prev_out[1015];
		temp_cin[0][1] = out[1015];
		temp_cin[1][0] = prev_out[973];
		temp_cin[1][1] = out[973];
		temp_cout[0][0] = prev_out[1878];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1878] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1879:
		temp_cin[0][0] = prev_out[1237];
		temp_cin[0][1] = out[1237];
		temp_cin[1][0] = prev_out[1187];
		temp_cin[1][1] = out[1187];
		temp_cout[0][0] = prev_out[1879];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1879] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1880:
		temp_cin[0][0] = prev_out[1009];
		temp_cin[0][1] = out[1009];
		temp_cin[1][0] = prev_out[968];
		temp_cin[1][1] = out[968];
		temp_cout[0][0] = prev_out[1880];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1880] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1881:
		temp_cin[0][0] = prev_out[841];
		temp_cin[0][1] = out[841];
		temp_cin[1][0] = prev_out[1593];
		temp_cin[1][1] = out[1593];
		temp_cout[0][0] = prev_out[1881];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1881] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1882:
		temp_cin[0][0] = prev_out[813];
		temp_cin[0][1] = out[813];
		temp_cin[1][0] = prev_out[1594];
		temp_cin[1][1] = out[1594];
		temp_cout[0][0] = prev_out[1882];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1882] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1883:
		temp_cin[0][0] = prev_out[1004];
		temp_cin[0][1] = out[1004];
		temp_cin[1][0] = prev_out[1595];
		temp_cin[1][1] = out[1595];
		temp_cout[0][0] = prev_out[1883];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1883] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1884:
		temp_cin[0][0] = prev_out[964];
		temp_cin[0][1] = out[964];
		temp_cin[1][0] = prev_out[1596];
		temp_cin[1][1] = out[1596];
		temp_cout[0][0] = prev_out[1884];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1884] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1885:
		temp_cin[0][0] = prev_out[1006];
		temp_cin[0][1] = out[1006];
		temp_cin[1][0] = prev_out[1597];
		temp_cin[1][1] = out[1597];
		temp_cout[0][0] = prev_out[1885];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1885] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1886:
		temp_cin[0][0] = prev_out[966];
		temp_cin[0][1] = out[966];
		temp_cin[1][0] = prev_out[1598];
		temp_cin[1][1] = out[1598];
		temp_cout[0][0] = prev_out[1886];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1886] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1887:
		temp_cin[0][0] = prev_out[1228];
		temp_cin[0][1] = out[1228];
		temp_cin[1][0] = prev_out[1599];
		temp_cin[1][1] = out[1599];
		temp_cout[0][0] = prev_out[1887];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1887] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1888:
		temp_cin[0][0] = prev_out[1178];
		temp_cin[0][1] = out[1178];
		temp_cin[1][0] = prev_out[1600];
		temp_cin[1][1] = out[1600];
		temp_cout[0][0] = prev_out[1888];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1888] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1889:
		temp_cin[0][0] = in_params[166][-1];
		temp_cin[0][1] = in_params[166][0];
		temp_cout[0][0] = prev_out[1889];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1889] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1890:
		temp_cin[0][0] = prev_out[280];
		temp_cin[0][1] = out[280];
		temp_cout[0][0] = prev_out[1890];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1890] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1891:
		temp_cin[0][0] = prev_out[1602];
		temp_cin[0][1] = out[1602];
		temp_cin[1][0] = prev_out[1601];
		temp_cin[1][1] = out[1601];
		temp_cout[0][0] = prev_out[1891];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1891] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1892:
		temp_cin[0][0] = prev_out[1891];
		temp_cin[0][1] = out[1891];
		temp_cout[0][0] = prev_out[1892];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1892] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1893:
		temp_cin[0][0] = prev_out[1604];
		temp_cin[0][1] = out[1604];
		temp_cin[1][0] = prev_out[1603];
		temp_cin[1][1] = out[1603];
		temp_cout[0][0] = prev_out[1893];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1893] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1894:
		temp_cin[0][0] = prev_out[280];
		temp_cin[0][1] = out[280];
		temp_cin[1][0] = prev_out[1605];
		temp_cin[1][1] = out[1605];
		temp_cout[0][0] = prev_out[1894];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1894] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1895:
		temp_cin[0][0] = prev_out[1607];
		temp_cin[0][1] = out[1607];
		temp_cin[1][0] = prev_out[1606];
		temp_cin[1][1] = out[1606];
		temp_cout[0][0] = prev_out[1895];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1895] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1896:
		temp_cin[0][0] = prev_out[900];
		temp_cin[0][1] = out[900];
		temp_cin[1][0] = prev_out[1608];
		temp_cin[1][1] = out[1608];
		temp_cout[0][0] = prev_out[1896];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1896] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1897:
		temp_cin[0][0] = prev_out[1610];
		temp_cin[0][1] = out[1610];
		temp_cin[1][0] = prev_out[1609];
		temp_cin[1][1] = out[1609];
		temp_cout[0][0] = prev_out[1897];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1897] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1898:
		temp_cin[0][0] = prev_out[900];
		temp_cin[0][1] = out[900];
		temp_cin[1][0] = prev_out[1611];
		temp_cin[1][1] = out[1611];
		temp_cout[0][0] = prev_out[1898];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1898] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1899:
		temp_cin[0][0] = prev_out[296];
		temp_cin[0][1] = out[296];
		temp_cout[0][0] = prev_out[1899];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1899] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1900:
		temp_cin[0][0] = prev_out[1613];
		temp_cin[0][1] = out[1613];
		temp_cin[1][0] = prev_out[1612];
		temp_cin[1][1] = out[1612];
		temp_cout[0][0] = prev_out[1900];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1900] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1901:
		temp_cin[0][0] = prev_out[1900];
		temp_cin[0][1] = out[1900];
		temp_cout[0][0] = prev_out[1901];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1901] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1902:
		temp_cin[0][0] = prev_out[1615];
		temp_cin[0][1] = out[1615];
		temp_cin[1][0] = prev_out[1614];
		temp_cin[1][1] = out[1614];
		temp_cout[0][0] = prev_out[1902];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1902] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1903:
		temp_cin[0][0] = prev_out[1902];
		temp_cin[0][1] = out[1902];
		temp_cout[0][0] = prev_out[1903];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1903] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1904:
		temp_cin[0][0] = prev_out[1617];
		temp_cin[0][1] = out[1617];
		temp_cin[1][0] = prev_out[1616];
		temp_cin[1][1] = out[1616];
		temp_cout[0][0] = prev_out[1904];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1904] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1905:
		temp_cin[0][0] = prev_out[1619];
		temp_cin[0][1] = out[1619];
		temp_cin[1][0] = prev_out[1618];
		temp_cin[1][1] = out[1618];
		temp_cout[0][0] = prev_out[1905];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1905] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1906:
		temp_cin[0][0] = prev_out[296];
		temp_cin[0][1] = out[296];
		temp_cin[1][0] = prev_out[1620];
		temp_cin[1][1] = out[1620];
		temp_cout[0][0] = prev_out[1906];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1906] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1907:
		temp_cin[0][0] = prev_out[120];
		temp_cin[0][1] = out[120];
		temp_cin[1][0] = prev_out[122];
		temp_cin[1][1] = out[122];
		temp_cin[2][0] = prev_out[124];
		temp_cin[2][1] = out[124];
		temp_cin[3][0] = prev_out[296];
		temp_cin[3][1] = out[296];
		temp_cin[4][0] = prev_out[745];
		temp_cin[4][1] = out[745];
		temp_cout[0][0] = prev_out[1907];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1907] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1908:
		temp_cin[0][0] = prev_out[1622];
		temp_cin[0][1] = out[1622];
		temp_cin[1][0] = prev_out[1621];
		temp_cin[1][1] = out[1621];
		temp_cout[0][0] = prev_out[1908];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1908] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1909:
		temp_cin[0][0] = prev_out[1352];
		temp_cin[0][1] = out[1352];
		temp_cin[1][0] = prev_out[1623];
		temp_cin[1][1] = out[1623];
		temp_cout[0][0] = prev_out[1909];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1909] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1910:
		temp_cin[0][0] = prev_out[1625];
		temp_cin[0][1] = out[1625];
		temp_cin[1][0] = prev_out[1624];
		temp_cin[1][1] = out[1624];
		temp_cout[0][0] = prev_out[1910];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1910] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1911:
		temp_cin[0][0] = prev_out[1352];
		temp_cin[0][1] = out[1352];
		temp_cin[1][0] = prev_out[1626];
		temp_cin[1][1] = out[1626];
		temp_cout[0][0] = prev_out[1911];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1911] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1912:
		temp_cin[0][0] = prev_out[312];
		temp_cin[0][1] = out[312];
		temp_cout[0][0] = prev_out[1912];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1912] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1913:
		temp_cin[0][0] = prev_out[1628];
		temp_cin[0][1] = out[1628];
		temp_cin[1][0] = prev_out[1627];
		temp_cin[1][1] = out[1627];
		temp_cout[0][0] = prev_out[1913];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1913] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1914:
		temp_cin[0][0] = prev_out[1913];
		temp_cin[0][1] = out[1913];
		temp_cout[0][0] = prev_out[1914];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1914] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1915:
		temp_cin[0][0] = prev_out[1633];
		temp_cin[0][1] = out[1633];
		temp_cin[1][0] = prev_out[1629];
		temp_cin[1][1] = out[1629];
		temp_cout[0][0] = prev_out[1915];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1915] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1916:
		temp_cin[0][0] = prev_out[1631];
		temp_cin[0][1] = out[1631];
		temp_cin[1][0] = prev_out[1630];
		temp_cin[1][1] = out[1630];
		temp_cout[0][0] = prev_out[1916];
		or_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1916] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1917:
		temp_cin[0][0] = prev_out[1633];
		temp_cin[0][1] = out[1633];
		temp_cin[1][0] = prev_out[1632];
		temp_cin[1][1] = out[1632];
		temp_cout[0][0] = prev_out[1917];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1917] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1918:
		temp_cin[0][0] = prev_out[1637];
		temp_cin[0][1] = out[1637];
		temp_cin[1][0] = prev_out[1636];
		temp_cin[1][1] = out[1636];
		temp_cin[2][0] = prev_out[1635];
		temp_cin[2][1] = out[1635];
		temp_cin[3][0] = prev_out[1634];
		temp_cin[3][1] = out[1634];
		temp_cout[0][0] = prev_out[1918];
		or_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1918] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1919:
		temp_cin[0][0] = prev_out[1639];
		temp_cin[0][1] = out[1639];
		temp_cin[1][0] = prev_out[1638];
		temp_cin[1][1] = out[1638];
		temp_cout[0][0] = prev_out[1919];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1919] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1920:
		temp_cin[0][0] = prev_out[312];
		temp_cin[0][1] = out[312];
		temp_cin[1][0] = prev_out[1640];
		temp_cin[1][1] = out[1640];
		temp_cout[0][0] = prev_out[1920];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1920] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1921:
		temp_cin[0][0] = prev_out[129];
		temp_cin[0][1] = out[129];
		temp_cin[1][0] = prev_out[131];
		temp_cin[1][1] = out[131];
		temp_cin[2][0] = prev_out[133];
		temp_cin[2][1] = out[133];
		temp_cin[3][0] = prev_out[312];
		temp_cin[3][1] = out[312];
		temp_cin[4][0] = prev_out[760];
		temp_cin[4][1] = out[760];
		temp_cout[0][0] = prev_out[1921];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1921] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1922:
		temp_cin[0][0] = prev_out[1645];
		temp_cin[0][1] = out[1645];
		temp_cin[1][0] = prev_out[1644];
		temp_cin[1][1] = out[1644];
		temp_cin[2][0] = prev_out[1643];
		temp_cin[2][1] = out[1643];
		temp_cin[3][0] = prev_out[1642];
		temp_cin[3][1] = out[1642];
		temp_cin[4][0] = prev_out[1641];
		temp_cin[4][1] = out[1641];
		temp_cout[0][0] = prev_out[1922];
		or_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1922] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1923:
		temp_cin[0][0] = prev_out[1647];
		temp_cin[0][1] = out[1647];
		temp_cin[1][0] = prev_out[1646];
		temp_cin[1][1] = out[1646];
		temp_cout[0][0] = prev_out[1923];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1923] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1924:
		temp_cin[0][0] = prev_out[575];
		temp_cin[0][1] = out[575];
		temp_cin[1][0] = prev_out[1648];
		temp_cin[1][1] = out[1648];
		temp_cout[0][0] = prev_out[1924];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1924] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1925:
		temp_cin[0][0] = prev_out[1650];
		temp_cin[0][1] = out[1650];
		temp_cin[1][0] = prev_out[1649];
		temp_cin[1][1] = out[1649];
		temp_cout[0][0] = prev_out[1925];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1925] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1926:
		temp_cin[0][0] = prev_out[575];
		temp_cin[0][1] = out[575];
		temp_cin[1][0] = prev_out[1651];
		temp_cin[1][1] = out[1651];
		temp_cout[0][0] = prev_out[1926];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1926] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1927:
		temp_cin[0][0] = prev_out[322];
		temp_cin[0][1] = out[322];
		temp_cout[0][0] = prev_out[1927];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1927] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1928:
		temp_cin[0][0] = prev_out[1653];
		temp_cin[0][1] = out[1653];
		temp_cin[1][0] = prev_out[1652];
		temp_cin[1][1] = out[1652];
		temp_cout[0][0] = prev_out[1928];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1928] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1929:
		temp_cin[0][0] = prev_out[1928];
		temp_cin[0][1] = out[1928];
		temp_cout[0][0] = prev_out[1929];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1929] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1930:
		temp_cin[0][0] = prev_out[1379];
		temp_cin[0][1] = out[1379];
		temp_cin[1][0] = prev_out[1346];
		temp_cin[1][1] = out[1346];
		temp_cout[0][0] = prev_out[1930];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1930] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1931:
		temp_cin[0][0] = prev_out[1359];
		temp_cin[0][1] = out[1359];
		temp_cin[1][0] = prev_out[1907];
		temp_cin[1][1] = out[1907];
		temp_cout[0][0] = prev_out[1931];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1931] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1932:
		temp_cin[0][0] = prev_out[1347];
		temp_cin[0][1] = out[1347];
		temp_cin[1][0] = prev_out[1654];
		temp_cin[1][1] = out[1654];
		temp_cout[0][0] = prev_out[1932];
		or_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1932] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1933:
		temp_cin[0][0] = prev_out[1656];
		temp_cin[0][1] = out[1656];
		temp_cin[1][0] = prev_out[1655];
		temp_cin[1][1] = out[1655];
		temp_cout[0][0] = prev_out[1933];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1933] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1934:
		temp_cin[0][0] = prev_out[322];
		temp_cin[0][1] = out[322];
		temp_cin[1][0] = prev_out[1657];
		temp_cin[1][1] = out[1657];
		temp_cout[0][0] = prev_out[1934];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1934] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1935:
		temp_cin[0][0] = prev_out[1659];
		temp_cin[0][1] = out[1659];
		temp_cin[1][0] = prev_out[1658];
		temp_cin[1][1] = out[1658];
		temp_cout[0][0] = prev_out[1935];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1935] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1936:
		temp_cin[0][0] = prev_out[1384];
		temp_cin[0][1] = out[1384];
		temp_cin[1][0] = prev_out[1660];
		temp_cin[1][1] = out[1660];
		temp_cout[0][0] = prev_out[1936];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1936] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1937:
		temp_cin[0][0] = prev_out[1662];
		temp_cin[0][1] = out[1662];
		temp_cin[1][0] = prev_out[1661];
		temp_cin[1][1] = out[1661];
		temp_cout[0][0] = prev_out[1937];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1937] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1938:
		temp_cin[0][0] = prev_out[1384];
		temp_cin[0][1] = out[1384];
		temp_cin[1][0] = prev_out[1663];
		temp_cin[1][1] = out[1663];
		temp_cout[0][0] = prev_out[1938];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1938] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1939:
		temp_cin[0][0] = prev_out[1670];
		temp_cin[0][1] = out[1670];
		temp_cin[1][0] = prev_out[1664];
		temp_cin[1][1] = out[1664];
		temp_cin[2][0] = prev_out[1668];
		temp_cin[2][1] = out[1668];
		temp_cin[3][0] = prev_out[1672];
		temp_cin[3][1] = out[1672];
		temp_cin[4][0] = prev_out[1666];
		temp_cin[4][1] = out[1666];
		temp_cout[0][0] = prev_out[1939];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1939] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1940:
		temp_cin[0][0] = prev_out[1666];
		temp_cin[0][1] = out[1666];
		temp_cin[1][0] = prev_out[1668];
		temp_cin[1][1] = out[1668];
		temp_cin[2][0] = prev_out[1672];
		temp_cin[2][1] = out[1672];
		temp_cin[3][0] = prev_out[1665];
		temp_cin[3][1] = out[1665];
		temp_cin[4][0] = prev_out[1670];
		temp_cin[4][1] = out[1670];
		temp_cout[0][0] = prev_out[1940];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1940] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1941:
		temp_cin[0][0] = prev_out[1668];
		temp_cin[0][1] = out[1668];
		temp_cin[1][0] = prev_out[1672];
		temp_cin[1][1] = out[1672];
		temp_cin[2][0] = prev_out[1667];
		temp_cin[2][1] = out[1667];
		temp_cin[3][0] = prev_out[1670];
		temp_cin[3][1] = out[1670];
		temp_cout[0][0] = prev_out[1941];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1941] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1942:
		temp_cin[0][0] = prev_out[1670];
		temp_cin[0][1] = out[1670];
		temp_cin[1][0] = prev_out[1672];
		temp_cin[1][1] = out[1672];
		temp_cin[2][0] = prev_out[1669];
		temp_cin[2][1] = out[1669];
		temp_cout[0][0] = prev_out[1942];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1942] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1943:
		temp_cin[0][0] = prev_out[1672];
		temp_cin[0][1] = out[1672];
		temp_cin[1][0] = prev_out[1671];
		temp_cin[1][1] = out[1671];
		temp_cout[0][0] = prev_out[1943];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1943] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1944:
		temp_cin[0][0] = prev_out[591];
		temp_cin[0][1] = out[591];
		temp_cin[1][0] = prev_out[542];
		temp_cin[1][1] = out[542];
		temp_cout[0][0] = prev_out[1944];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1944] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1945:
		temp_cin[0][0] = prev_out[1676];
		temp_cin[0][1] = out[1676];
		temp_cin[1][0] = prev_out[1675];
		temp_cin[1][1] = out[1675];
		temp_cin[2][0] = prev_out[1674];
		temp_cin[2][1] = out[1674];
		temp_cin[3][0] = prev_out[1673];
		temp_cin[3][1] = out[1673];
		temp_cout[0][0] = prev_out[1945];
		or_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1945] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1946:
		temp_cin[0][0] = prev_out[274];
		temp_cin[0][1] = out[274];
		temp_cin[1][0] = prev_out[1677];
		temp_cin[1][1] = out[1677];
		temp_cout[0][0] = prev_out[1946];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1946] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1947:
		temp_cin[0][0] = prev_out[214];
		temp_cin[0][1] = out[214];
		temp_cin[1][0] = prev_out[1678];
		temp_cin[1][1] = out[1678];
		temp_cout[0][0] = prev_out[1947];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1947] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1948:
		temp_cin[0][0] = prev_out[399];
		temp_cin[0][1] = out[399];
		temp_cin[1][0] = prev_out[1679];
		temp_cin[1][1] = out[1679];
		temp_cout[0][0] = prev_out[1948];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1948] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1949:
		temp_cin[0][0] = prev_out[336];
		temp_cin[0][1] = out[336];
		temp_cin[1][0] = prev_out[1680];
		temp_cin[1][1] = out[1680];
		temp_cout[0][0] = prev_out[1949];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1949] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1950:
		temp_cin[0][0] = in_params[11][-1];
		temp_cin[0][1] = in_params[11][0];
		temp_cout[0][0] = prev_out[1950];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1950] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1951:
		temp_cin[0][0] = prev_out[464];
		temp_cin[0][1] = out[464];
		temp_cout[0][0] = prev_out[1951];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1951] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1952:
		temp_cin[0][0] = prev_out[1682];
		temp_cin[0][1] = out[1682];
		temp_cin[1][0] = prev_out[1681];
		temp_cin[1][1] = out[1681];
		temp_cout[0][0] = prev_out[1952];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1952] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1953:
		temp_cin[0][0] = prev_out[1403];
		temp_cin[0][1] = out[1403];
		temp_cin[1][0] = prev_out[1683];
		temp_cin[1][1] = out[1683];
		temp_cout[0][0] = prev_out[1953];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1953] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1954:
		temp_cin[0][0] = prev_out[1687];
		temp_cin[0][1] = out[1687];
		temp_cin[1][0] = prev_out[1685];
		temp_cin[1][1] = out[1685];
		temp_cin[2][0] = prev_out[1684];
		temp_cin[2][1] = out[1684];
		temp_cout[0][0] = prev_out[1954];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1954] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1955:
		temp_cin[0][0] = prev_out[1688];
		temp_cin[0][1] = out[1688];
		temp_cin[1][0] = prev_out[1687];
		temp_cin[1][1] = out[1687];
		temp_cin[2][0] = prev_out[1686];
		temp_cin[2][1] = out[1686];
		temp_cout[0][0] = prev_out[1955];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1955] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1956:
		temp_cin[0][0] = prev_out[1690];
		temp_cin[0][1] = out[1690];
		temp_cin[1][0] = prev_out[1688];
		temp_cin[1][1] = out[1688];
		temp_cin[2][0] = prev_out[1684];
		temp_cin[2][1] = out[1684];
		temp_cout[0][0] = prev_out[1956];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1956] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1957:
		temp_cin[0][0] = prev_out[1685];
		temp_cin[0][1] = out[1685];
		temp_cin[1][0] = prev_out[1690];
		temp_cin[1][1] = out[1690];
		temp_cin[2][0] = prev_out[1689];
		temp_cin[2][1] = out[1689];
		temp_cout[0][0] = prev_out[1957];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1957] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1958:
		temp_cin[0][0] = prev_out[1692];
		temp_cin[0][1] = out[1692];
		temp_cin[1][0] = prev_out[1691];
		temp_cin[1][1] = out[1691];
		temp_cout[0][0] = prev_out[1958];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1958] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1959:
		temp_cin[0][0] = prev_out[1412];
		temp_cin[0][1] = out[1412];
		temp_cin[1][0] = prev_out[1693];
		temp_cin[1][1] = out[1693];
		temp_cout[0][0] = prev_out[1959];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1959] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1960:
		temp_cin[0][0] = prev_out[1697];
		temp_cin[0][1] = out[1697];
		temp_cin[1][0] = prev_out[1695];
		temp_cin[1][1] = out[1695];
		temp_cin[2][0] = prev_out[1694];
		temp_cin[2][1] = out[1694];
		temp_cout[0][0] = prev_out[1960];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1960] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1961:
		temp_cin[0][0] = prev_out[1698];
		temp_cin[0][1] = out[1698];
		temp_cin[1][0] = prev_out[1697];
		temp_cin[1][1] = out[1697];
		temp_cin[2][0] = prev_out[1696];
		temp_cin[2][1] = out[1696];
		temp_cout[0][0] = prev_out[1961];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1961] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1962:
		temp_cin[0][0] = prev_out[1700];
		temp_cin[0][1] = out[1700];
		temp_cin[1][0] = prev_out[1698];
		temp_cin[1][1] = out[1698];
		temp_cin[2][0] = prev_out[1694];
		temp_cin[2][1] = out[1694];
		temp_cout[0][0] = prev_out[1962];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1962] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1963:
		temp_cin[0][0] = prev_out[1695];
		temp_cin[0][1] = out[1695];
		temp_cin[1][0] = prev_out[1700];
		temp_cin[1][1] = out[1700];
		temp_cin[2][0] = prev_out[1699];
		temp_cin[2][1] = out[1699];
		temp_cout[0][0] = prev_out[1963];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1963] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1964:
		temp_cin[0][0] = prev_out[1702];
		temp_cin[0][1] = out[1702];
		temp_cin[1][0] = prev_out[1701];
		temp_cin[1][1] = out[1701];
		temp_cout[0][0] = prev_out[1964];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1964] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1965:
		temp_cin[0][0] = prev_out[1421];
		temp_cin[0][1] = out[1421];
		temp_cin[1][0] = prev_out[1703];
		temp_cin[1][1] = out[1703];
		temp_cout[0][0] = prev_out[1965];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1965] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1966:
		temp_cin[0][0] = prev_out[1707];
		temp_cin[0][1] = out[1707];
		temp_cin[1][0] = prev_out[1705];
		temp_cin[1][1] = out[1705];
		temp_cin[2][0] = prev_out[1704];
		temp_cin[2][1] = out[1704];
		temp_cout[0][0] = prev_out[1966];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1966] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1967:
		temp_cin[0][0] = prev_out[1708];
		temp_cin[0][1] = out[1708];
		temp_cin[1][0] = prev_out[1707];
		temp_cin[1][1] = out[1707];
		temp_cin[2][0] = prev_out[1706];
		temp_cin[2][1] = out[1706];
		temp_cout[0][0] = prev_out[1967];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1967] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1968:
		temp_cin[0][0] = prev_out[1710];
		temp_cin[0][1] = out[1710];
		temp_cin[1][0] = prev_out[1708];
		temp_cin[1][1] = out[1708];
		temp_cin[2][0] = prev_out[1704];
		temp_cin[2][1] = out[1704];
		temp_cout[0][0] = prev_out[1968];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1968] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1969:
		temp_cin[0][0] = prev_out[1705];
		temp_cin[0][1] = out[1705];
		temp_cin[1][0] = prev_out[1710];
		temp_cin[1][1] = out[1710];
		temp_cin[2][0] = prev_out[1709];
		temp_cin[2][1] = out[1709];
		temp_cout[0][0] = prev_out[1969];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1969] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1970:
		temp_cin[0][0] = prev_out[1712];
		temp_cin[0][1] = out[1712];
		temp_cin[1][0] = prev_out[1711];
		temp_cin[1][1] = out[1711];
		temp_cout[0][0] = prev_out[1970];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1970] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1971:
		temp_cin[0][0] = prev_out[1430];
		temp_cin[0][1] = out[1430];
		temp_cin[1][0] = prev_out[1713];
		temp_cin[1][1] = out[1713];
		temp_cout[0][0] = prev_out[1971];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1971] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1972:
		temp_cin[0][0] = prev_out[1717];
		temp_cin[0][1] = out[1717];
		temp_cin[1][0] = prev_out[1715];
		temp_cin[1][1] = out[1715];
		temp_cin[2][0] = prev_out[1714];
		temp_cin[2][1] = out[1714];
		temp_cout[0][0] = prev_out[1972];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1972] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1973:
		temp_cin[0][0] = prev_out[1718];
		temp_cin[0][1] = out[1718];
		temp_cin[1][0] = prev_out[1717];
		temp_cin[1][1] = out[1717];
		temp_cin[2][0] = prev_out[1716];
		temp_cin[2][1] = out[1716];
		temp_cout[0][0] = prev_out[1973];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1973] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1974:
		temp_cin[0][0] = prev_out[1720];
		temp_cin[0][1] = out[1720];
		temp_cin[1][0] = prev_out[1718];
		temp_cin[1][1] = out[1718];
		temp_cin[2][0] = prev_out[1714];
		temp_cin[2][1] = out[1714];
		temp_cout[0][0] = prev_out[1974];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1974] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1975:
		temp_cin[0][0] = prev_out[1715];
		temp_cin[0][1] = out[1715];
		temp_cin[1][0] = prev_out[1720];
		temp_cin[1][1] = out[1720];
		temp_cin[2][0] = prev_out[1719];
		temp_cin[2][1] = out[1719];
		temp_cout[0][0] = prev_out[1975];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1975] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1976:
		temp_cin[0][0] = prev_out[1722];
		temp_cin[0][1] = out[1722];
		temp_cin[1][0] = prev_out[1721];
		temp_cin[1][1] = out[1721];
		temp_cout[0][0] = prev_out[1976];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1976] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1977:
		temp_cin[0][0] = prev_out[1438];
		temp_cin[0][1] = out[1438];
		temp_cin[1][0] = prev_out[1723];
		temp_cin[1][1] = out[1723];
		temp_cout[0][0] = prev_out[1977];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1977] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1978:
		temp_cin[0][0] = prev_out[1727];
		temp_cin[0][1] = out[1727];
		temp_cin[1][0] = prev_out[1725];
		temp_cin[1][1] = out[1725];
		temp_cin[2][0] = prev_out[1724];
		temp_cin[2][1] = out[1724];
		temp_cout[0][0] = prev_out[1978];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1978] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1979:
		temp_cin[0][0] = prev_out[1728];
		temp_cin[0][1] = out[1728];
		temp_cin[1][0] = prev_out[1727];
		temp_cin[1][1] = out[1727];
		temp_cin[2][0] = prev_out[1726];
		temp_cin[2][1] = out[1726];
		temp_cout[0][0] = prev_out[1979];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1979] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1980:
		temp_cin[0][0] = prev_out[1730];
		temp_cin[0][1] = out[1730];
		temp_cin[1][0] = prev_out[1728];
		temp_cin[1][1] = out[1728];
		temp_cin[2][0] = prev_out[1724];
		temp_cin[2][1] = out[1724];
		temp_cout[0][0] = prev_out[1980];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1980] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1981:
		temp_cin[0][0] = prev_out[1725];
		temp_cin[0][1] = out[1725];
		temp_cin[1][0] = prev_out[1730];
		temp_cin[1][1] = out[1730];
		temp_cin[2][0] = prev_out[1729];
		temp_cin[2][1] = out[1729];
		temp_cout[0][0] = prev_out[1981];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1981] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1982:
		temp_cin[0][0] = prev_out[1732];
		temp_cin[0][1] = out[1732];
		temp_cin[1][0] = prev_out[1731];
		temp_cin[1][1] = out[1731];
		temp_cout[0][0] = prev_out[1982];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1982] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1983:
		temp_cin[0][0] = prev_out[1447];
		temp_cin[0][1] = out[1447];
		temp_cin[1][0] = prev_out[1733];
		temp_cin[1][1] = out[1733];
		temp_cout[0][0] = prev_out[1983];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1983] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1984:
		temp_cin[0][0] = prev_out[1737];
		temp_cin[0][1] = out[1737];
		temp_cin[1][0] = prev_out[1735];
		temp_cin[1][1] = out[1735];
		temp_cin[2][0] = prev_out[1734];
		temp_cin[2][1] = out[1734];
		temp_cout[0][0] = prev_out[1984];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1984] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1985:
		temp_cin[0][0] = prev_out[1738];
		temp_cin[0][1] = out[1738];
		temp_cin[1][0] = prev_out[1737];
		temp_cin[1][1] = out[1737];
		temp_cin[2][0] = prev_out[1736];
		temp_cin[2][1] = out[1736];
		temp_cout[0][0] = prev_out[1985];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1985] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1986:
		temp_cin[0][0] = prev_out[1740];
		temp_cin[0][1] = out[1740];
		temp_cin[1][0] = prev_out[1738];
		temp_cin[1][1] = out[1738];
		temp_cin[2][0] = prev_out[1734];
		temp_cin[2][1] = out[1734];
		temp_cout[0][0] = prev_out[1986];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1986] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1987:
		temp_cin[0][0] = prev_out[1735];
		temp_cin[0][1] = out[1735];
		temp_cin[1][0] = prev_out[1740];
		temp_cin[1][1] = out[1740];
		temp_cin[2][0] = prev_out[1739];
		temp_cin[2][1] = out[1739];
		temp_cout[0][0] = prev_out[1987];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1987] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1988:
		temp_cin[0][0] = prev_out[1742];
		temp_cin[0][1] = out[1742];
		temp_cin[1][0] = prev_out[1741];
		temp_cin[1][1] = out[1741];
		temp_cout[0][0] = prev_out[1988];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1988] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1989:
		temp_cin[0][0] = prev_out[1456];
		temp_cin[0][1] = out[1456];
		temp_cin[1][0] = prev_out[1743];
		temp_cin[1][1] = out[1743];
		temp_cout[0][0] = prev_out[1989];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1989] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1990:
		temp_cin[0][0] = prev_out[1747];
		temp_cin[0][1] = out[1747];
		temp_cin[1][0] = prev_out[1745];
		temp_cin[1][1] = out[1745];
		temp_cin[2][0] = prev_out[1744];
		temp_cin[2][1] = out[1744];
		temp_cout[0][0] = prev_out[1990];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1990] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1991:
		temp_cin[0][0] = prev_out[1748];
		temp_cin[0][1] = out[1748];
		temp_cin[1][0] = prev_out[1747];
		temp_cin[1][1] = out[1747];
		temp_cin[2][0] = prev_out[1746];
		temp_cin[2][1] = out[1746];
		temp_cout[0][0] = prev_out[1991];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1991] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1992:
		temp_cin[0][0] = prev_out[1750];
		temp_cin[0][1] = out[1750];
		temp_cin[1][0] = prev_out[1748];
		temp_cin[1][1] = out[1748];
		temp_cin[2][0] = prev_out[1744];
		temp_cin[2][1] = out[1744];
		temp_cout[0][0] = prev_out[1992];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1992] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1993:
		temp_cin[0][0] = prev_out[1745];
		temp_cin[0][1] = out[1745];
		temp_cin[1][0] = prev_out[1750];
		temp_cin[1][1] = out[1750];
		temp_cin[2][0] = prev_out[1749];
		temp_cin[2][1] = out[1749];
		temp_cout[0][0] = prev_out[1993];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1993] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1994:
		temp_cin[0][0] = prev_out[1752];
		temp_cin[0][1] = out[1752];
		temp_cin[1][0] = prev_out[1751];
		temp_cin[1][1] = out[1751];
		temp_cout[0][0] = prev_out[1994];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1994] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1995:
		temp_cin[0][0] = prev_out[1465];
		temp_cin[0][1] = out[1465];
		temp_cin[1][0] = prev_out[1753];
		temp_cin[1][1] = out[1753];
		temp_cout[0][0] = prev_out[1995];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1995] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1996:
		temp_cin[0][0] = prev_out[1757];
		temp_cin[0][1] = out[1757];
		temp_cin[1][0] = prev_out[1755];
		temp_cin[1][1] = out[1755];
		temp_cin[2][0] = prev_out[1754];
		temp_cin[2][1] = out[1754];
		temp_cout[0][0] = prev_out[1996];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1996] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1997:
		temp_cin[0][0] = prev_out[1758];
		temp_cin[0][1] = out[1758];
		temp_cin[1][0] = prev_out[1757];
		temp_cin[1][1] = out[1757];
		temp_cin[2][0] = prev_out[1756];
		temp_cin[2][1] = out[1756];
		temp_cout[0][0] = prev_out[1997];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1997] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1998:
		temp_cin[0][0] = prev_out[1760];
		temp_cin[0][1] = out[1760];
		temp_cin[1][0] = prev_out[1758];
		temp_cin[1][1] = out[1758];
		temp_cin[2][0] = prev_out[1754];
		temp_cin[2][1] = out[1754];
		temp_cout[0][0] = prev_out[1998];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1998] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 1999:
		temp_cin[0][0] = prev_out[1755];
		temp_cin[0][1] = out[1755];
		temp_cin[1][0] = prev_out[1760];
		temp_cin[1][1] = out[1760];
		temp_cin[2][0] = prev_out[1759];
		temp_cin[2][1] = out[1759];
		temp_cout[0][0] = prev_out[1999];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[1999] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2000:
		temp_cin[0][0] = prev_out[1762];
		temp_cin[0][1] = out[1762];
		temp_cin[1][0] = prev_out[1761];
		temp_cin[1][1] = out[1761];
		temp_cout[0][0] = prev_out[2000];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2000] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2001:
		temp_cin[0][0] = prev_out[1474];
		temp_cin[0][1] = out[1474];
		temp_cin[1][0] = prev_out[1763];
		temp_cin[1][1] = out[1763];
		temp_cout[0][0] = prev_out[2001];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2001] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2002:
		temp_cin[0][0] = prev_out[1767];
		temp_cin[0][1] = out[1767];
		temp_cin[1][0] = prev_out[1765];
		temp_cin[1][1] = out[1765];
		temp_cin[2][0] = prev_out[1764];
		temp_cin[2][1] = out[1764];
		temp_cout[0][0] = prev_out[2002];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2002] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2003:
		temp_cin[0][0] = prev_out[1768];
		temp_cin[0][1] = out[1768];
		temp_cin[1][0] = prev_out[1767];
		temp_cin[1][1] = out[1767];
		temp_cin[2][0] = prev_out[1766];
		temp_cin[2][1] = out[1766];
		temp_cout[0][0] = prev_out[2003];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2003] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2004:
		temp_cin[0][0] = prev_out[1770];
		temp_cin[0][1] = out[1770];
		temp_cin[1][0] = prev_out[1768];
		temp_cin[1][1] = out[1768];
		temp_cin[2][0] = prev_out[1764];
		temp_cin[2][1] = out[1764];
		temp_cout[0][0] = prev_out[2004];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2004] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2005:
		temp_cin[0][0] = prev_out[1765];
		temp_cin[0][1] = out[1765];
		temp_cin[1][0] = prev_out[1770];
		temp_cin[1][1] = out[1770];
		temp_cin[2][0] = prev_out[1769];
		temp_cin[2][1] = out[1769];
		temp_cout[0][0] = prev_out[2005];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2005] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2006:
		temp_cin[0][0] = prev_out[1772];
		temp_cin[0][1] = out[1772];
		temp_cin[1][0] = prev_out[1771];
		temp_cin[1][1] = out[1771];
		temp_cout[0][0] = prev_out[2006];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2006] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2007:
		temp_cin[0][0] = prev_out[1483];
		temp_cin[0][1] = out[1483];
		temp_cin[1][0] = prev_out[1773];
		temp_cin[1][1] = out[1773];
		temp_cout[0][0] = prev_out[2007];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2007] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2008:
		temp_cin[0][0] = prev_out[1777];
		temp_cin[0][1] = out[1777];
		temp_cin[1][0] = prev_out[1775];
		temp_cin[1][1] = out[1775];
		temp_cin[2][0] = prev_out[1774];
		temp_cin[2][1] = out[1774];
		temp_cout[0][0] = prev_out[2008];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2008] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2009:
		temp_cin[0][0] = prev_out[1778];
		temp_cin[0][1] = out[1778];
		temp_cin[1][0] = prev_out[1777];
		temp_cin[1][1] = out[1777];
		temp_cin[2][0] = prev_out[1776];
		temp_cin[2][1] = out[1776];
		temp_cout[0][0] = prev_out[2009];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2009] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2010:
		temp_cin[0][0] = prev_out[1780];
		temp_cin[0][1] = out[1780];
		temp_cin[1][0] = prev_out[1778];
		temp_cin[1][1] = out[1778];
		temp_cin[2][0] = prev_out[1774];
		temp_cin[2][1] = out[1774];
		temp_cout[0][0] = prev_out[2010];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2010] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2011:
		temp_cin[0][0] = prev_out[1775];
		temp_cin[0][1] = out[1775];
		temp_cin[1][0] = prev_out[1780];
		temp_cin[1][1] = out[1780];
		temp_cin[2][0] = prev_out[1779];
		temp_cin[2][1] = out[1779];
		temp_cout[0][0] = prev_out[2011];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2011] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2012:
		temp_cin[0][0] = prev_out[1782];
		temp_cin[0][1] = out[1782];
		temp_cin[1][0] = prev_out[1781];
		temp_cin[1][1] = out[1781];
		temp_cout[0][0] = prev_out[2012];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2012] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2013:
		temp_cin[0][0] = prev_out[1492];
		temp_cin[0][1] = out[1492];
		temp_cin[1][0] = prev_out[1783];
		temp_cin[1][1] = out[1783];
		temp_cout[0][0] = prev_out[2013];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2013] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2014:
		temp_cin[0][0] = prev_out[1787];
		temp_cin[0][1] = out[1787];
		temp_cin[1][0] = prev_out[1785];
		temp_cin[1][1] = out[1785];
		temp_cin[2][0] = prev_out[1784];
		temp_cin[2][1] = out[1784];
		temp_cout[0][0] = prev_out[2014];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2014] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2015:
		temp_cin[0][0] = prev_out[1788];
		temp_cin[0][1] = out[1788];
		temp_cin[1][0] = prev_out[1787];
		temp_cin[1][1] = out[1787];
		temp_cin[2][0] = prev_out[1786];
		temp_cin[2][1] = out[1786];
		temp_cout[0][0] = prev_out[2015];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2015] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2016:
		temp_cin[0][0] = prev_out[1790];
		temp_cin[0][1] = out[1790];
		temp_cin[1][0] = prev_out[1788];
		temp_cin[1][1] = out[1788];
		temp_cin[2][0] = prev_out[1784];
		temp_cin[2][1] = out[1784];
		temp_cout[0][0] = prev_out[2016];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2016] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2017:
		temp_cin[0][0] = prev_out[1785];
		temp_cin[0][1] = out[1785];
		temp_cin[1][0] = prev_out[1790];
		temp_cin[1][1] = out[1790];
		temp_cin[2][0] = prev_out[1789];
		temp_cin[2][1] = out[1789];
		temp_cout[0][0] = prev_out[2017];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2017] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2018:
		temp_cin[0][0] = prev_out[1792];
		temp_cin[0][1] = out[1792];
		temp_cin[1][0] = prev_out[1791];
		temp_cin[1][1] = out[1791];
		temp_cout[0][0] = prev_out[2018];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2018] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2019:
		temp_cin[0][0] = prev_out[1501];
		temp_cin[0][1] = out[1501];
		temp_cin[1][0] = prev_out[1793];
		temp_cin[1][1] = out[1793];
		temp_cout[0][0] = prev_out[2019];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2019] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2020:
		temp_cin[0][0] = prev_out[1797];
		temp_cin[0][1] = out[1797];
		temp_cin[1][0] = prev_out[1795];
		temp_cin[1][1] = out[1795];
		temp_cin[2][0] = prev_out[1794];
		temp_cin[2][1] = out[1794];
		temp_cout[0][0] = prev_out[2020];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2020] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2021:
		temp_cin[0][0] = prev_out[1798];
		temp_cin[0][1] = out[1798];
		temp_cin[1][0] = prev_out[1797];
		temp_cin[1][1] = out[1797];
		temp_cin[2][0] = prev_out[1796];
		temp_cin[2][1] = out[1796];
		temp_cout[0][0] = prev_out[2021];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2021] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2022:
		temp_cin[0][0] = prev_out[1800];
		temp_cin[0][1] = out[1800];
		temp_cin[1][0] = prev_out[1798];
		temp_cin[1][1] = out[1798];
		temp_cin[2][0] = prev_out[1794];
		temp_cin[2][1] = out[1794];
		temp_cout[0][0] = prev_out[2022];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2022] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2023:
		temp_cin[0][0] = prev_out[1795];
		temp_cin[0][1] = out[1795];
		temp_cin[1][0] = prev_out[1800];
		temp_cin[1][1] = out[1800];
		temp_cin[2][0] = prev_out[1799];
		temp_cin[2][1] = out[1799];
		temp_cout[0][0] = prev_out[2023];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2023] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2024:
		temp_cin[0][0] = prev_out[1802];
		temp_cin[0][1] = out[1802];
		temp_cin[1][0] = prev_out[1801];
		temp_cin[1][1] = out[1801];
		temp_cout[0][0] = prev_out[2024];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2024] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2025:
		temp_cin[0][0] = prev_out[1804];
		temp_cin[0][1] = out[1804];
		temp_cin[1][0] = prev_out[1803];
		temp_cin[1][1] = out[1803];
		temp_cout[0][0] = prev_out[2025];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2025] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2026:
		temp_cin[0][0] = prev_out[1806];
		temp_cin[0][1] = out[1806];
		temp_cin[1][0] = prev_out[1805];
		temp_cin[1][1] = out[1805];
		temp_cout[0][0] = prev_out[2026];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2026] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2027:
		temp_cin[0][0] = prev_out[1808];
		temp_cin[0][1] = out[1808];
		temp_cin[1][0] = prev_out[1807];
		temp_cin[1][1] = out[1807];
		temp_cout[0][0] = prev_out[2027];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2027] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2028:
		temp_cin[0][0] = prev_out[1810];
		temp_cin[0][1] = out[1810];
		temp_cin[1][0] = prev_out[1809];
		temp_cin[1][1] = out[1809];
		temp_cout[0][0] = prev_out[2028];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2028] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2029:
		temp_cin[0][0] = prev_out[1820];
		temp_cin[0][1] = out[1820];
		temp_cin[1][0] = prev_out[1811];
		temp_cin[1][1] = out[1811];
		temp_cin[2][0] = prev_out[1818];
		temp_cin[2][1] = out[1818];
		temp_cin[3][0] = prev_out[1822];
		temp_cin[3][1] = out[1822];
		temp_cout[0][0] = prev_out[2029];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2029] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2030:
		temp_cin[0][0] = prev_out[1816];
		temp_cin[0][1] = out[1816];
		temp_cin[1][0] = prev_out[1815];
		temp_cin[1][1] = out[1815];
		temp_cin[2][0] = prev_out[1814];
		temp_cin[2][1] = out[1814];
		temp_cin[3][0] = prev_out[1813];
		temp_cin[3][1] = out[1813];
		temp_cin[4][0] = prev_out[1812];
		temp_cin[4][1] = out[1812];
		temp_cout[0][0] = prev_out[2030];
		or_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2030] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2031:
		temp_cin[0][0] = prev_out[1818];
		temp_cin[0][1] = out[1818];
		temp_cin[1][0] = prev_out[1822];
		temp_cin[1][1] = out[1822];
		temp_cin[2][0] = prev_out[1817];
		temp_cin[2][1] = out[1817];
		temp_cin[3][0] = prev_out[1820];
		temp_cin[3][1] = out[1820];
		temp_cout[0][0] = prev_out[2031];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2031] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2032:
		temp_cin[0][0] = prev_out[1820];
		temp_cin[0][1] = out[1820];
		temp_cin[1][0] = prev_out[1822];
		temp_cin[1][1] = out[1822];
		temp_cin[2][0] = prev_out[1819];
		temp_cin[2][1] = out[1819];
		temp_cout[0][0] = prev_out[2032];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2032] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2033:
		temp_cin[0][0] = prev_out[1822];
		temp_cin[0][1] = out[1822];
		temp_cin[1][0] = prev_out[1821];
		temp_cin[1][1] = out[1821];
		temp_cout[0][0] = prev_out[2033];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2033] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2034:
		temp_cin[0][0] = prev_out[906];
		temp_cin[0][1] = out[906];
		temp_cin[1][0] = prev_out[756];
		temp_cin[1][1] = out[756];
		temp_cout[0][0] = prev_out[2034];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2034] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2035:
		temp_cin[0][0] = prev_out[1824];
		temp_cin[0][1] = out[1824];
		temp_cin[1][0] = prev_out[1823];
		temp_cin[1][1] = out[1823];
		temp_cout[0][0] = prev_out[2035];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2035] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2036:
		temp_cin[0][0] = prev_out[2024];
		temp_cin[0][1] = out[2024];
		temp_cin[1][0] = prev_out[2026];
		temp_cin[1][1] = out[2026];
		temp_cin[2][0] = prev_out[2025];
		temp_cin[2][1] = out[2025];
		temp_cin[3][0] = prev_out[1825];
		temp_cin[3][1] = out[1825];
		temp_cin[4][0] = prev_out[2028];
		temp_cin[4][1] = out[2028];
		temp_cout[0][0] = prev_out[2036];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2036] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2037:
		temp_cin[0][0] = prev_out[2026];
		temp_cin[0][1] = out[2026];
		temp_cin[1][0] = prev_out[2025];
		temp_cin[1][1] = out[2025];
		temp_cin[2][0] = prev_out[1826];
		temp_cin[2][1] = out[1826];
		temp_cin[3][0] = prev_out[2028];
		temp_cin[3][1] = out[2028];
		temp_cout[0][0] = prev_out[2037];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2037] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2038:
		temp_cin[0][0] = prev_out[2028];
		temp_cin[0][1] = out[2028];
		temp_cin[1][0] = prev_out[2025];
		temp_cin[1][1] = out[2025];
		temp_cin[2][0] = prev_out[1827];
		temp_cin[2][1] = out[1827];
		temp_cout[0][0] = prev_out[2038];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2038] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2039:
		temp_cin[0][0] = prev_out[2025];
		temp_cin[0][1] = out[2025];
		temp_cin[1][0] = prev_out[1828];
		temp_cin[1][1] = out[1828];
		temp_cout[0][0] = prev_out[2039];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2039] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2040:
		temp_cin[0][0] = prev_out[630];
		temp_cin[0][1] = out[630];
		temp_cin[1][0] = prev_out[578];
		temp_cin[1][1] = out[578];
		temp_cout[0][0] = prev_out[2040];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2040] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2041:
		temp_cin[0][0] = prev_out[399];
		temp_cin[0][1] = out[399];
		temp_cin[1][0] = prev_out[336];
		temp_cin[1][1] = out[336];
		temp_cout[0][0] = prev_out[2041];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2041] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2042:
		temp_cin[0][0] = prev_out[1830];
		temp_cin[0][1] = out[1830];
		temp_cin[1][0] = prev_out[1829];
		temp_cin[1][1] = out[1829];
		temp_cout[0][0] = prev_out[2042];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2042] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2043:
		temp_cin[0][0] = prev_out[1832];
		temp_cin[0][1] = out[1832];
		temp_cin[1][0] = prev_out[1831];
		temp_cin[1][1] = out[1831];
		temp_cout[0][0] = prev_out[2043];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2043] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2044:
		temp_cin[0][0] = prev_out[1400];
		temp_cin[0][1] = out[1400];
		temp_cin[1][0] = prev_out[1833];
		temp_cin[1][1] = out[1833];
		temp_cin[2][0] = prev_out[1398];
		temp_cin[2][1] = out[1398];
		temp_cin[3][0] = prev_out[1402];
		temp_cin[3][1] = out[1402];
		temp_cout[0][0] = prev_out[2044];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2044] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2045:
		temp_cin[0][0] = prev_out[1838];
		temp_cin[0][1] = out[1838];
		temp_cin[1][0] = prev_out[1837];
		temp_cin[1][1] = out[1837];
		temp_cin[2][0] = prev_out[1836];
		temp_cin[2][1] = out[1836];
		temp_cin[3][0] = prev_out[1835];
		temp_cin[3][1] = out[1835];
		temp_cin[4][0] = prev_out[1834];
		temp_cin[4][1] = out[1834];
		temp_cout[0][0] = prev_out[2045];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2045] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2046:
		temp_cin[0][0] = prev_out[1842];
		temp_cin[0][1] = out[1842];
		temp_cin[1][0] = prev_out[1841];
		temp_cin[1][1] = out[1841];
		temp_cin[2][0] = prev_out[1840];
		temp_cin[2][1] = out[1840];
		temp_cin[3][0] = prev_out[1839];
		temp_cin[3][1] = out[1839];
		temp_cout[0][0] = prev_out[2046];
		or_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2046] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2047:
		temp_cin[0][0] = prev_out[1844];
		temp_cin[0][1] = out[1844];
		temp_cin[1][0] = prev_out[1843];
		temp_cin[1][1] = out[1843];
		temp_cout[0][0] = prev_out[2047];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2047] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2048:
		temp_cin[0][0] = prev_out[1846];
		temp_cin[0][1] = out[1846];
		temp_cin[1][0] = prev_out[1845];
		temp_cin[1][1] = out[1845];
		temp_cout[0][0] = prev_out[2048];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2048] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2049:
		temp_cin[0][0] = prev_out[1848];
		temp_cin[0][1] = out[1848];
		temp_cin[1][0] = prev_out[1847];
		temp_cin[1][1] = out[1847];
		temp_cout[0][0] = prev_out[2049];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2049] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2050:
		temp_cin[0][0] = prev_out[1850];
		temp_cin[0][1] = out[1850];
		temp_cin[1][0] = prev_out[1849];
		temp_cin[1][1] = out[1849];
		temp_cout[0][0] = prev_out[2050];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2050] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2051:
		temp_cin[0][0] = prev_out[1852];
		temp_cin[0][1] = out[1852];
		temp_cin[1][0] = prev_out[1851];
		temp_cin[1][1] = out[1851];
		temp_cout[0][0] = prev_out[2051];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2051] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2052:
		temp_cin[0][0] = prev_out[1857];
		temp_cin[0][1] = out[1857];
		temp_cin[1][0] = prev_out[1856];
		temp_cin[1][1] = out[1856];
		temp_cin[2][0] = prev_out[1855];
		temp_cin[2][1] = out[1855];
		temp_cin[3][0] = prev_out[1854];
		temp_cin[3][1] = out[1854];
		temp_cin[4][0] = prev_out[1853];
		temp_cin[4][1] = out[1853];
		temp_cout[0][0] = prev_out[2052];
		or_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2052] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2053:
		temp_cin[0][0] = prev_out[1858];
		temp_cin[0][1] = out[1858];
		temp_cin[1][0] = prev_out[1554];
		temp_cin[1][1] = out[1554];
		temp_cin[2][0] = prev_out[1556];
		temp_cin[2][1] = out[1556];
		temp_cin[3][0] = prev_out[1558];
		temp_cin[3][1] = out[1558];
		temp_cout[0][0] = prev_out[2053];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2053] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2054:
		temp_cin[0][0] = prev_out[1860];
		temp_cin[0][1] = out[1860];
		temp_cin[1][0] = prev_out[1859];
		temp_cin[1][1] = out[1859];
		temp_cout[0][0] = prev_out[2054];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2054] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2055:
		temp_cin[0][0] = prev_out[1862];
		temp_cin[0][1] = out[1862];
		temp_cin[1][0] = prev_out[1861];
		temp_cin[1][1] = out[1861];
		temp_cout[0][0] = prev_out[2055];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2055] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2056:
		temp_cin[0][0] = prev_out[1864];
		temp_cin[0][1] = out[1864];
		temp_cin[1][0] = prev_out[1863];
		temp_cin[1][1] = out[1863];
		temp_cout[0][0] = prev_out[2056];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2056] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2057:
		temp_cin[0][0] = prev_out[1866];
		temp_cin[0][1] = out[1866];
		temp_cin[1][0] = prev_out[1865];
		temp_cin[1][1] = out[1865];
		temp_cout[0][0] = prev_out[2057];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2057] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2058:
		temp_cin[0][0] = prev_out[1868];
		temp_cin[0][1] = out[1868];
		temp_cin[1][0] = prev_out[1867];
		temp_cin[1][1] = out[1867];
		temp_cout[0][0] = prev_out[2058];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2058] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2059:
		temp_cin[0][0] = prev_out[1873];
		temp_cin[0][1] = out[1873];
		temp_cin[1][0] = prev_out[1872];
		temp_cin[1][1] = out[1872];
		temp_cin[2][0] = prev_out[1871];
		temp_cin[2][1] = out[1871];
		temp_cin[3][0] = prev_out[1870];
		temp_cin[3][1] = out[1870];
		temp_cin[4][0] = prev_out[1869];
		temp_cin[4][1] = out[1869];
		temp_cout[0][0] = prev_out[2059];
		or_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2059] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2060:
		temp_cin[0][0] = prev_out[2050];
		temp_cin[0][1] = out[2050];
		temp_cin[1][0] = prev_out[2048];
		temp_cin[1][1] = out[2048];
		temp_cin[2][0] = prev_out[1874];
		temp_cin[2][1] = out[1874];
		temp_cin[3][0] = prev_out[2049];
		temp_cin[3][1] = out[2049];
		temp_cout[0][0] = prev_out[2060];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2060] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2061:
		temp_cin[0][0] = prev_out[2049];
		temp_cin[0][1] = out[2049];
		temp_cin[1][0] = prev_out[2048];
		temp_cin[1][1] = out[2048];
		temp_cin[2][0] = prev_out[1875];
		temp_cin[2][1] = out[1875];
		temp_cout[0][0] = prev_out[2061];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2061] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2062:
		temp_cin[0][0] = prev_out[2048];
		temp_cin[0][1] = out[2048];
		temp_cin[1][0] = prev_out[1876];
		temp_cin[1][1] = out[1876];
		temp_cout[0][0] = prev_out[2062];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2062] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2063:
		temp_cin[0][0] = prev_out[1216];
		temp_cin[0][1] = out[1216];
		temp_cin[1][0] = prev_out[1166];
		temp_cin[1][1] = out[1166];
		temp_cout[0][0] = prev_out[2063];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2063] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2064:
		temp_cin[0][0] = prev_out[2057];
		temp_cin[0][1] = out[2057];
		temp_cin[1][0] = prev_out[2056];
		temp_cin[1][1] = out[2056];
		temp_cin[2][0] = prev_out[2054];
		temp_cin[2][1] = out[2054];
		temp_cin[3][0] = prev_out[1877];
		temp_cin[3][1] = out[1877];
		temp_cin[4][0] = prev_out[2055];
		temp_cin[4][1] = out[2055];
		temp_cout[0][0] = prev_out[2064];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2064] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2065:
		temp_cin[0][0] = prev_out[2056];
		temp_cin[0][1] = out[2056];
		temp_cin[1][0] = prev_out[2054];
		temp_cin[1][1] = out[2054];
		temp_cin[2][0] = prev_out[1878];
		temp_cin[2][1] = out[1878];
		temp_cin[3][0] = prev_out[2055];
		temp_cin[3][1] = out[2055];
		temp_cout[0][0] = prev_out[2065];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2065] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2066:
		temp_cin[0][0] = prev_out[2055];
		temp_cin[0][1] = out[2055];
		temp_cin[1][0] = prev_out[2054];
		temp_cin[1][1] = out[2054];
		temp_cin[2][0] = prev_out[1879];
		temp_cin[2][1] = out[1879];
		temp_cout[0][0] = prev_out[2066];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2066] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2067:
		temp_cin[0][0] = prev_out[2054];
		temp_cin[0][1] = out[2054];
		temp_cin[1][0] = prev_out[1880];
		temp_cin[1][1] = out[1880];
		temp_cout[0][0] = prev_out[2067];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2067] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2068:
		temp_cin[0][0] = prev_out[1231];
		temp_cin[0][1] = out[1231];
		temp_cin[1][0] = prev_out[1181];
		temp_cin[1][1] = out[1181];
		temp_cout[0][0] = prev_out[2068];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2068] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2069:
		temp_cin[0][0] = prev_out[1882];
		temp_cin[0][1] = out[1882];
		temp_cin[1][0] = prev_out[1881];
		temp_cin[1][1] = out[1881];
		temp_cout[0][0] = prev_out[2069];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2069] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2070:
		temp_cin[0][0] = prev_out[841];
		temp_cin[0][1] = out[841];
		temp_cin[1][0] = prev_out[813];
		temp_cin[1][1] = out[813];
		temp_cout[0][0] = prev_out[2070];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2070] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2071:
		temp_cin[0][0] = prev_out[1884];
		temp_cin[0][1] = out[1884];
		temp_cin[1][0] = prev_out[1883];
		temp_cin[1][1] = out[1883];
		temp_cout[0][0] = prev_out[2071];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2071] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2072:
		temp_cin[0][0] = prev_out[1004];
		temp_cin[0][1] = out[1004];
		temp_cin[1][0] = prev_out[964];
		temp_cin[1][1] = out[964];
		temp_cout[0][0] = prev_out[2072];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2072] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2073:
		temp_cin[0][0] = prev_out[1886];
		temp_cin[0][1] = out[1886];
		temp_cin[1][0] = prev_out[1885];
		temp_cin[1][1] = out[1885];
		temp_cout[0][0] = prev_out[2073];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2073] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2074:
		temp_cin[0][0] = prev_out[1006];
		temp_cin[0][1] = out[1006];
		temp_cin[1][0] = prev_out[966];
		temp_cin[1][1] = out[966];
		temp_cout[0][0] = prev_out[2074];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2074] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2075:
		temp_cin[0][0] = prev_out[1888];
		temp_cin[0][1] = out[1888];
		temp_cin[1][0] = prev_out[1887];
		temp_cin[1][1] = out[1887];
		temp_cout[0][0] = prev_out[2075];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2075] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2076:
		temp_cin[0][0] = in_params[174][-1];
		temp_cin[0][1] = in_params[174][0];
		temp_cout[0][0] = prev_out[2076];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2076] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2077:
		temp_cin[0][0] = in_params[206][-1];
		temp_cin[0][1] = in_params[206][0];
		temp_cin[1][0] = prev_out[1889];
		temp_cin[1][1] = out[1889];
		temp_cout[0][0] = prev_out[2077];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2077] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2078:
		temp_cin[0][0] = prev_out[1891];
		temp_cin[0][1] = out[1891];
		temp_cin[1][0] = prev_out[1890];
		temp_cin[1][1] = out[1890];
		temp_cout[0][0] = prev_out[2078];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2078] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2079:
		temp_cin[0][0] = prev_out[280];
		temp_cin[0][1] = out[280];
		temp_cin[1][0] = prev_out[1892];
		temp_cin[1][1] = out[1892];
		temp_cout[0][0] = prev_out[2079];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2079] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2080:
		temp_cin[0][0] = prev_out[1894];
		temp_cin[0][1] = out[1894];
		temp_cin[1][0] = prev_out[1893];
		temp_cin[1][1] = out[1893];
		temp_cout[0][0] = prev_out[2080];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2080] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2081:
		temp_cin[0][0] = prev_out[1346];
		temp_cin[0][1] = out[1346];
		temp_cout[0][0] = prev_out[2081];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2081] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2082:
		temp_cin[0][0] = prev_out[446];
		temp_cin[0][1] = out[446];
		temp_cout[0][0] = prev_out[2082];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2082] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2083:
		temp_cin[0][0] = prev_out[1896];
		temp_cin[0][1] = out[1896];
		temp_cin[1][0] = prev_out[1895];
		temp_cin[1][1] = out[1895];
		temp_cout[0][0] = prev_out[2083];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2083] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2084:
		temp_cin[0][0] = prev_out[2083];
		temp_cin[0][1] = out[2083];
		temp_cout[0][0] = prev_out[2084];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2084] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2085:
		temp_cin[0][0] = prev_out[446];
		temp_cin[0][1] = out[446];
		temp_cout[0][0] = prev_out[2085];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2085] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2086:
		temp_cin[0][0] = prev_out[1898];
		temp_cin[0][1] = out[1898];
		temp_cin[1][0] = prev_out[1897];
		temp_cin[1][1] = out[1897];
		temp_cout[0][0] = prev_out[2086];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2086] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2087:
		temp_cin[0][0] = prev_out[2086];
		temp_cin[0][1] = out[2086];
		temp_cout[0][0] = prev_out[2087];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2087] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2088:
		temp_cin[0][0] = prev_out[1900];
		temp_cin[0][1] = out[1900];
		temp_cin[1][0] = prev_out[1899];
		temp_cin[1][1] = out[1899];
		temp_cout[0][0] = prev_out[2088];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2088] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2089:
		temp_cin[0][0] = prev_out[296];
		temp_cin[0][1] = out[296];
		temp_cin[1][0] = prev_out[1901];
		temp_cin[1][1] = out[1901];
		temp_cout[0][0] = prev_out[2089];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2089] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2090:
		temp_cin[0][0] = prev_out[1902];
		temp_cin[0][1] = out[1902];
		temp_cin[1][0] = prev_out[1347];
		temp_cin[1][1] = out[1347];
		temp_cout[0][0] = prev_out[2090];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2090] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2091:
		temp_cin[0][0] = prev_out[1904];
		temp_cin[0][1] = out[1904];
		temp_cin[1][0] = prev_out[1903];
		temp_cin[1][1] = out[1903];
		temp_cout[0][0] = prev_out[2091];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2091] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2092:
		temp_cin[0][0] = prev_out[1906];
		temp_cin[0][1] = out[1906];
		temp_cin[1][0] = prev_out[1905];
		temp_cin[1][1] = out[1905];
		temp_cout[0][0] = prev_out[2092];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2092] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2093:
		temp_cin[0][0] = prev_out[1907];
		temp_cin[0][1] = out[1907];
		temp_cout[0][0] = prev_out[2093];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2093] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2094:
		temp_cin[0][0] = prev_out[1358];
		temp_cin[0][1] = out[1358];
		temp_cout[0][0] = prev_out[2094];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2094] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2095:
		temp_cin[0][0] = prev_out[454];
		temp_cin[0][1] = out[454];
		temp_cout[0][0] = prev_out[2095];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2095] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2096:
		temp_cin[0][0] = prev_out[1909];
		temp_cin[0][1] = out[1909];
		temp_cin[1][0] = prev_out[1908];
		temp_cin[1][1] = out[1908];
		temp_cout[0][0] = prev_out[2096];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2096] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2097:
		temp_cin[0][0] = prev_out[2096];
		temp_cin[0][1] = out[2096];
		temp_cout[0][0] = prev_out[2097];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2097] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2098:
		temp_cin[0][0] = prev_out[454];
		temp_cin[0][1] = out[454];
		temp_cout[0][0] = prev_out[2098];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2098] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2099:
		temp_cin[0][0] = prev_out[1911];
		temp_cin[0][1] = out[1911];
		temp_cin[1][0] = prev_out[1910];
		temp_cin[1][1] = out[1910];
		temp_cout[0][0] = prev_out[2099];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2099] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2100:
		temp_cin[0][0] = prev_out[2099];
		temp_cin[0][1] = out[2099];
		temp_cout[0][0] = prev_out[2100];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2100] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2101:
		temp_cin[0][0] = prev_out[1913];
		temp_cin[0][1] = out[1913];
		temp_cin[1][0] = prev_out[1912];
		temp_cin[1][1] = out[1912];
		temp_cout[0][0] = prev_out[2101];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2101] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2102:
		temp_cin[0][0] = prev_out[312];
		temp_cin[0][1] = out[312];
		temp_cin[1][0] = prev_out[1914];
		temp_cin[1][1] = out[1914];
		temp_cout[0][0] = prev_out[2102];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2102] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2103:
		temp_cin[0][0] = in_params[205][-1];
		temp_cin[0][1] = in_params[205][0];
		temp_cin[1][0] = prev_out[1930];
		temp_cin[1][1] = out[1930];
		temp_cin[2][0] = prev_out[1931];
		temp_cin[2][1] = out[1931];
		temp_cin[3][0] = prev_out[1915];
		temp_cin[3][1] = out[1915];
		temp_cout[0][0] = prev_out[2103];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2103] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2104:
		temp_cin[0][0] = prev_out[1932];
		temp_cin[0][1] = out[1932];
		temp_cin[1][0] = prev_out[1931];
		temp_cin[1][1] = out[1931];
		temp_cin[2][0] = prev_out[1915];
		temp_cin[2][1] = out[1915];
		temp_cout[0][0] = prev_out[2104];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2104] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2105:
		temp_cin[0][0] = prev_out[1916];
		temp_cin[0][1] = out[1916];
		temp_cin[1][0] = prev_out[1915];
		temp_cin[1][1] = out[1915];
		temp_cout[0][0] = prev_out[2105];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2105] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2106:
		temp_cin[0][0] = prev_out[1918];
		temp_cin[0][1] = out[1918];
		temp_cin[1][0] = prev_out[1917];
		temp_cin[1][1] = out[1917];
		temp_cout[0][0] = prev_out[2106];
		or_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2106] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2107:
		temp_cin[0][0] = prev_out[1920];
		temp_cin[0][1] = out[1920];
		temp_cin[1][0] = prev_out[1919];
		temp_cin[1][1] = out[1919];
		temp_cout[0][0] = prev_out[2107];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2107] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2108:
		temp_cin[0][0] = prev_out[1921];
		temp_cin[0][1] = out[1921];
		temp_cout[0][0] = prev_out[2108];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2108] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2109:
		temp_cin[0][0] = prev_out[1922];
		temp_cin[0][1] = out[1922];
		temp_cout[0][0] = prev_out[2109];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2109] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2110:
		temp_cin[0][0] = prev_out[574];
		temp_cin[0][1] = out[574];
		temp_cout[0][0] = prev_out[2110];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2110] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2111:
		temp_cin[0][0] = prev_out[1924];
		temp_cin[0][1] = out[1924];
		temp_cin[1][0] = prev_out[1923];
		temp_cin[1][1] = out[1923];
		temp_cout[0][0] = prev_out[2111];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2111] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2112:
		temp_cin[0][0] = prev_out[2111];
		temp_cin[0][1] = out[2111];
		temp_cout[0][0] = prev_out[2112];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2112] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2113:
		temp_cin[0][0] = prev_out[574];
		temp_cin[0][1] = out[574];
		temp_cout[0][0] = prev_out[2113];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2113] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2114:
		temp_cin[0][0] = prev_out[1926];
		temp_cin[0][1] = out[1926];
		temp_cin[1][0] = prev_out[1925];
		temp_cin[1][1] = out[1925];
		temp_cout[0][0] = prev_out[2114];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2114] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2115:
		temp_cin[0][0] = prev_out[2114];
		temp_cin[0][1] = out[2114];
		temp_cout[0][0] = prev_out[2115];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2115] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2116:
		temp_cin[0][0] = prev_out[1928];
		temp_cin[0][1] = out[1928];
		temp_cin[1][0] = prev_out[1927];
		temp_cin[1][1] = out[1927];
		temp_cout[0][0] = prev_out[2116];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2116] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2117:
		temp_cin[0][0] = prev_out[322];
		temp_cin[0][1] = out[322];
		temp_cin[1][0] = prev_out[1929];
		temp_cin[1][1] = out[1929];
		temp_cout[0][0] = prev_out[2117];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2117] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2118:
		temp_cin[0][0] = in_params[205][-1];
		temp_cin[0][1] = in_params[205][0];
		temp_cin[1][0] = prev_out[1930];
		temp_cin[1][1] = out[1930];
		temp_cin[2][0] = prev_out[1931];
		temp_cin[2][1] = out[1931];
		temp_cout[0][0] = prev_out[2118];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2118] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2119:
		temp_cin[0][0] = prev_out[1932];
		temp_cin[0][1] = out[1932];
		temp_cin[1][0] = prev_out[1931];
		temp_cin[1][1] = out[1931];
		temp_cout[0][0] = prev_out[2119];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2119] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2120:
		temp_cin[0][0] = prev_out[1934];
		temp_cin[0][1] = out[1934];
		temp_cin[1][0] = prev_out[1933];
		temp_cin[1][1] = out[1933];
		temp_cout[0][0] = prev_out[2120];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2120] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2121:
		temp_cin[0][0] = prev_out[1629];
		temp_cin[0][1] = out[1629];
		temp_cout[0][0] = prev_out[2121];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2121] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2122:
		temp_cin[0][0] = prev_out[1632];
		temp_cin[0][1] = out[1632];
		temp_cout[0][0] = prev_out[2122];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2122] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2123:
		temp_cin[0][0] = prev_out[476];
		temp_cin[0][1] = out[476];
		temp_cout[0][0] = prev_out[2123];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2123] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2124:
		temp_cin[0][0] = prev_out[1936];
		temp_cin[0][1] = out[1936];
		temp_cin[1][0] = prev_out[1935];
		temp_cin[1][1] = out[1935];
		temp_cout[0][0] = prev_out[2124];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2124] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2125:
		temp_cin[0][0] = prev_out[2124];
		temp_cin[0][1] = out[2124];
		temp_cout[0][0] = prev_out[2125];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2125] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2126:
		temp_cin[0][0] = prev_out[476];
		temp_cin[0][1] = out[476];
		temp_cout[0][0] = prev_out[2126];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2126] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2127:
		temp_cin[0][0] = prev_out[1938];
		temp_cin[0][1] = out[1938];
		temp_cin[1][0] = prev_out[1937];
		temp_cin[1][1] = out[1937];
		temp_cout[0][0] = prev_out[2127];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2127] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2128:
		temp_cin[0][0] = prev_out[2127];
		temp_cin[0][1] = out[2127];
		temp_cout[0][0] = prev_out[2128];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2128] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2129:
		temp_cin[0][0] = prev_out[1939];
		temp_cin[0][1] = out[1939];
		temp_cin[1][0] = in_params[205][-1];
		temp_cin[1][1] = in_params[205][0];
		temp_cout[0][0] = prev_out[2129];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2129] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2130:
		temp_cin[0][0] = prev_out[1944];
		temp_cin[0][1] = out[1944];
		temp_cin[1][0] = prev_out[1943];
		temp_cin[1][1] = out[1943];
		temp_cin[2][0] = prev_out[1942];
		temp_cin[2][1] = out[1942];
		temp_cin[3][0] = prev_out[1941];
		temp_cin[3][1] = out[1941];
		temp_cin[4][0] = prev_out[1940];
		temp_cin[4][1] = out[1940];
		temp_cout[0][0] = prev_out[2130];
		or_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2130] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2131:
		temp_cin[0][0] = prev_out[2044];
		temp_cin[0][1] = out[2044];
		temp_cout[0][0] = prev_out[2131];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2131] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2132:
		temp_cin[0][0] = prev_out[1945];
		temp_cin[0][1] = out[1945];
		temp_cout[0][0] = prev_out[2132];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2132] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2133:
		temp_cin[0][0] = prev_out[1947];
		temp_cin[0][1] = out[1947];
		temp_cin[1][0] = prev_out[1946];
		temp_cin[1][1] = out[1946];
		temp_cout[0][0] = prev_out[2133];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2133] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2134:
		temp_cin[0][0] = prev_out[215];
		temp_cin[0][1] = out[215];
		temp_cin[1][0] = prev_out[277];
		temp_cin[1][1] = out[277];
		temp_cout[0][0] = prev_out[2134];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2134] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2135:
		temp_cin[0][0] = prev_out[274];
		temp_cin[0][1] = out[274];
		temp_cin[1][0] = prev_out[214];
		temp_cin[1][1] = out[214];
		temp_cout[0][0] = prev_out[2135];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2135] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2136:
		temp_cin[0][0] = prev_out[1949];
		temp_cin[0][1] = out[1949];
		temp_cin[1][0] = prev_out[1948];
		temp_cin[1][1] = out[1948];
		temp_cout[0][0] = prev_out[2136];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2136] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2137:
		temp_cin[0][0] = prev_out[41];
		temp_cin[0][1] = out[41];
		temp_cout[0][0] = prev_out[2137];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2137] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2138:
		temp_cin[0][0] = prev_out[66];
		temp_cin[0][1] = out[66];
		temp_cout[0][0] = prev_out[2138];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2138] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2139:
		temp_cin[0][0] = in_params[11][-1];
		temp_cin[0][1] = in_params[11][0];
		temp_cout[0][0] = prev_out[2139];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2139] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2140:
		temp_cin[0][0] = prev_out[467];
		temp_cin[0][1] = out[467];
		temp_cout[0][0] = prev_out[2140];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2140] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2141:
		temp_cin[0][0] = prev_out[464];
		temp_cin[0][1] = out[464];
		temp_cin[1][0] = prev_out[1950];
		temp_cin[1][1] = out[1950];
		temp_cout[0][0] = prev_out[2141];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2141] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2142:
		temp_cin[0][0] = in_params[11][-1];
		temp_cin[0][1] = in_params[11][0];
		temp_cin[1][0] = prev_out[1951];
		temp_cin[1][1] = out[1951];
		temp_cout[0][0] = prev_out[2142];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2142] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2143:
		temp_cin[0][0] = prev_out[1953];
		temp_cin[0][1] = out[1953];
		temp_cin[1][0] = prev_out[1952];
		temp_cin[1][1] = out[1952];
		temp_cout[0][0] = prev_out[2143];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2143] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2144:
		temp_cin[0][0] = prev_out[1955];
		temp_cin[0][1] = out[1955];
		temp_cin[1][0] = prev_out[1954];
		temp_cin[1][1] = out[1954];
		temp_cout[0][0] = prev_out[2144];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2144] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2145:
		temp_cin[0][0] = prev_out[1957];
		temp_cin[0][1] = out[1957];
		temp_cin[1][0] = prev_out[1956];
		temp_cin[1][1] = out[1956];
		temp_cout[0][0] = prev_out[2145];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2145] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2146:
		temp_cin[0][0] = prev_out[1959];
		temp_cin[0][1] = out[1959];
		temp_cin[1][0] = prev_out[1958];
		temp_cin[1][1] = out[1958];
		temp_cout[0][0] = prev_out[2146];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2146] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2147:
		temp_cin[0][0] = prev_out[1961];
		temp_cin[0][1] = out[1961];
		temp_cin[1][0] = prev_out[1960];
		temp_cin[1][1] = out[1960];
		temp_cout[0][0] = prev_out[2147];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2147] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2148:
		temp_cin[0][0] = prev_out[1963];
		temp_cin[0][1] = out[1963];
		temp_cin[1][0] = prev_out[1962];
		temp_cin[1][1] = out[1962];
		temp_cout[0][0] = prev_out[2148];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2148] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2149:
		temp_cin[0][0] = prev_out[1965];
		temp_cin[0][1] = out[1965];
		temp_cin[1][0] = prev_out[1964];
		temp_cin[1][1] = out[1964];
		temp_cout[0][0] = prev_out[2149];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2149] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2150:
		temp_cin[0][0] = prev_out[1967];
		temp_cin[0][1] = out[1967];
		temp_cin[1][0] = prev_out[1966];
		temp_cin[1][1] = out[1966];
		temp_cout[0][0] = prev_out[2150];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2150] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2151:
		temp_cin[0][0] = prev_out[1969];
		temp_cin[0][1] = out[1969];
		temp_cin[1][0] = prev_out[1968];
		temp_cin[1][1] = out[1968];
		temp_cout[0][0] = prev_out[2151];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2151] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2152:
		temp_cin[0][0] = prev_out[1971];
		temp_cin[0][1] = out[1971];
		temp_cin[1][0] = prev_out[1970];
		temp_cin[1][1] = out[1970];
		temp_cout[0][0] = prev_out[2152];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2152] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2153:
		temp_cin[0][0] = prev_out[1973];
		temp_cin[0][1] = out[1973];
		temp_cin[1][0] = prev_out[1972];
		temp_cin[1][1] = out[1972];
		temp_cout[0][0] = prev_out[2153];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2153] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2154:
		temp_cin[0][0] = prev_out[1975];
		temp_cin[0][1] = out[1975];
		temp_cin[1][0] = prev_out[1974];
		temp_cin[1][1] = out[1974];
		temp_cout[0][0] = prev_out[2154];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2154] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2155:
		temp_cin[0][0] = prev_out[1977];
		temp_cin[0][1] = out[1977];
		temp_cin[1][0] = prev_out[1976];
		temp_cin[1][1] = out[1976];
		temp_cout[0][0] = prev_out[2155];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2155] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2156:
		temp_cin[0][0] = prev_out[1979];
		temp_cin[0][1] = out[1979];
		temp_cin[1][0] = prev_out[1978];
		temp_cin[1][1] = out[1978];
		temp_cout[0][0] = prev_out[2156];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2156] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2157:
		temp_cin[0][0] = prev_out[1981];
		temp_cin[0][1] = out[1981];
		temp_cin[1][0] = prev_out[1980];
		temp_cin[1][1] = out[1980];
		temp_cout[0][0] = prev_out[2157];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2157] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2158:
		temp_cin[0][0] = prev_out[1983];
		temp_cin[0][1] = out[1983];
		temp_cin[1][0] = prev_out[1982];
		temp_cin[1][1] = out[1982];
		temp_cout[0][0] = prev_out[2158];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2158] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2159:
		temp_cin[0][0] = prev_out[1985];
		temp_cin[0][1] = out[1985];
		temp_cin[1][0] = prev_out[1984];
		temp_cin[1][1] = out[1984];
		temp_cout[0][0] = prev_out[2159];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2159] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2160:
		temp_cin[0][0] = prev_out[1987];
		temp_cin[0][1] = out[1987];
		temp_cin[1][0] = prev_out[1986];
		temp_cin[1][1] = out[1986];
		temp_cout[0][0] = prev_out[2160];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2160] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2161:
		temp_cin[0][0] = prev_out[1989];
		temp_cin[0][1] = out[1989];
		temp_cin[1][0] = prev_out[1988];
		temp_cin[1][1] = out[1988];
		temp_cout[0][0] = prev_out[2161];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2161] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2162:
		temp_cin[0][0] = prev_out[1991];
		temp_cin[0][1] = out[1991];
		temp_cin[1][0] = prev_out[1990];
		temp_cin[1][1] = out[1990];
		temp_cout[0][0] = prev_out[2162];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2162] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2163:
		temp_cin[0][0] = prev_out[1993];
		temp_cin[0][1] = out[1993];
		temp_cin[1][0] = prev_out[1992];
		temp_cin[1][1] = out[1992];
		temp_cout[0][0] = prev_out[2163];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2163] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2164:
		temp_cin[0][0] = prev_out[1995];
		temp_cin[0][1] = out[1995];
		temp_cin[1][0] = prev_out[1994];
		temp_cin[1][1] = out[1994];
		temp_cout[0][0] = prev_out[2164];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2164] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2165:
		temp_cin[0][0] = prev_out[1997];
		temp_cin[0][1] = out[1997];
		temp_cin[1][0] = prev_out[1996];
		temp_cin[1][1] = out[1996];
		temp_cout[0][0] = prev_out[2165];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2165] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2166:
		temp_cin[0][0] = prev_out[1999];
		temp_cin[0][1] = out[1999];
		temp_cin[1][0] = prev_out[1998];
		temp_cin[1][1] = out[1998];
		temp_cout[0][0] = prev_out[2166];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2166] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2167:
		temp_cin[0][0] = prev_out[2001];
		temp_cin[0][1] = out[2001];
		temp_cin[1][0] = prev_out[2000];
		temp_cin[1][1] = out[2000];
		temp_cout[0][0] = prev_out[2167];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2167] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2168:
		temp_cin[0][0] = prev_out[2003];
		temp_cin[0][1] = out[2003];
		temp_cin[1][0] = prev_out[2002];
		temp_cin[1][1] = out[2002];
		temp_cout[0][0] = prev_out[2168];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2168] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2169:
		temp_cin[0][0] = prev_out[2005];
		temp_cin[0][1] = out[2005];
		temp_cin[1][0] = prev_out[2004];
		temp_cin[1][1] = out[2004];
		temp_cout[0][0] = prev_out[2169];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2169] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2170:
		temp_cin[0][0] = prev_out[2007];
		temp_cin[0][1] = out[2007];
		temp_cin[1][0] = prev_out[2006];
		temp_cin[1][1] = out[2006];
		temp_cout[0][0] = prev_out[2170];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2170] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2171:
		temp_cin[0][0] = prev_out[2009];
		temp_cin[0][1] = out[2009];
		temp_cin[1][0] = prev_out[2008];
		temp_cin[1][1] = out[2008];
		temp_cout[0][0] = prev_out[2171];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2171] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2172:
		temp_cin[0][0] = prev_out[2011];
		temp_cin[0][1] = out[2011];
		temp_cin[1][0] = prev_out[2010];
		temp_cin[1][1] = out[2010];
		temp_cout[0][0] = prev_out[2172];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2172] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2173:
		temp_cin[0][0] = prev_out[2013];
		temp_cin[0][1] = out[2013];
		temp_cin[1][0] = prev_out[2012];
		temp_cin[1][1] = out[2012];
		temp_cout[0][0] = prev_out[2173];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2173] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2174:
		temp_cin[0][0] = prev_out[2015];
		temp_cin[0][1] = out[2015];
		temp_cin[1][0] = prev_out[2014];
		temp_cin[1][1] = out[2014];
		temp_cout[0][0] = prev_out[2174];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2174] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2175:
		temp_cin[0][0] = prev_out[2017];
		temp_cin[0][1] = out[2017];
		temp_cin[1][0] = prev_out[2016];
		temp_cin[1][1] = out[2016];
		temp_cout[0][0] = prev_out[2175];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2175] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2176:
		temp_cin[0][0] = prev_out[2019];
		temp_cin[0][1] = out[2019];
		temp_cin[1][0] = prev_out[2018];
		temp_cin[1][1] = out[2018];
		temp_cout[0][0] = prev_out[2176];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2176] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2177:
		temp_cin[0][0] = prev_out[2021];
		temp_cin[0][1] = out[2021];
		temp_cin[1][0] = prev_out[2020];
		temp_cin[1][1] = out[2020];
		temp_cout[0][0] = prev_out[2177];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2177] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2178:
		temp_cin[0][0] = prev_out[2023];
		temp_cin[0][1] = out[2023];
		temp_cin[1][0] = prev_out[2022];
		temp_cin[1][1] = out[2022];
		temp_cout[0][0] = prev_out[2178];
		nor_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2178] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2179:
		temp_cin[0][0] = prev_out[2028];
		temp_cin[0][1] = out[2028];
		temp_cin[1][0] = prev_out[2027];
		temp_cin[1][1] = out[2027];
		temp_cin[2][0] = prev_out[2026];
		temp_cin[2][1] = out[2026];
		temp_cin[3][0] = prev_out[2025];
		temp_cin[3][1] = out[2025];
		temp_cin[4][0] = prev_out[2024];
		temp_cin[4][1] = out[2024];
		temp_cout[0][0] = prev_out[2179];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2179] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2180:
		temp_cin[0][0] = prev_out[2030];
		temp_cin[0][1] = out[2030];
		temp_cin[1][0] = prev_out[2029];
		temp_cin[1][1] = out[2029];
		temp_cout[0][0] = prev_out[2180];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2180] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2181:
		temp_cin[0][0] = prev_out[2034];
		temp_cin[0][1] = out[2034];
		temp_cin[1][0] = prev_out[2033];
		temp_cin[1][1] = out[2033];
		temp_cin[2][0] = prev_out[2032];
		temp_cin[2][1] = out[2032];
		temp_cin[3][0] = prev_out[2031];
		temp_cin[3][1] = out[2031];
		temp_cout[0][0] = prev_out[2181];
		or_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2181] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2182:
		temp_cin[0][0] = prev_out[2136];
		temp_cin[0][1] = out[2136];
		temp_cin[1][0] = prev_out[2035];
		temp_cin[1][1] = out[2035];
		temp_cin[2][0] = prev_out[2133];
		temp_cin[2][1] = out[2133];
		temp_cin[3][0] = prev_out[2042];
		temp_cin[3][1] = out[2042];
		temp_cout[0][0] = prev_out[2182];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2182] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2183:
		temp_cin[0][0] = prev_out[2040];
		temp_cin[0][1] = out[2040];
		temp_cin[1][0] = prev_out[2039];
		temp_cin[1][1] = out[2039];
		temp_cin[2][0] = prev_out[2038];
		temp_cin[2][1] = out[2038];
		temp_cin[3][0] = prev_out[2037];
		temp_cin[3][1] = out[2037];
		temp_cin[4][0] = prev_out[2036];
		temp_cin[4][1] = out[2036];
		temp_cout[0][0] = prev_out[2183];
		or_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2183] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2184:
		temp_cin[0][0] = prev_out[2133];
		temp_cin[0][1] = out[2133];
		temp_cin[1][0] = prev_out[2042];
		temp_cin[1][1] = out[2042];
		temp_cin[2][0] = prev_out[2134];
		temp_cin[2][1] = out[2134];
		temp_cin[3][0] = prev_out[2136];
		temp_cin[3][1] = out[2136];
		temp_cout[0][0] = prev_out[2184];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2184] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2185:
		temp_cin[0][0] = prev_out[2136];
		temp_cin[0][1] = out[2136];
		temp_cin[1][0] = prev_out[2042];
		temp_cin[1][1] = out[2042];
		temp_cin[2][0] = prev_out[2135];
		temp_cin[2][1] = out[2135];
		temp_cout[0][0] = prev_out[2185];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2185] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2186:
		temp_cin[0][0] = prev_out[2042];
		temp_cin[0][1] = out[2042];
		temp_cin[1][0] = prev_out[2041];
		temp_cin[1][1] = out[2041];
		temp_cout[0][0] = prev_out[2186];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2186] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2187:
		temp_cin[0][0] = prev_out[929];
		temp_cin[0][1] = out[929];
		temp_cin[1][0] = prev_out[783];
		temp_cin[1][1] = out[783];
		temp_cout[0][0] = prev_out[2187];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2187] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2188:
		temp_cin[0][0] = prev_out[1526];
		temp_cin[0][1] = out[1526];
		temp_cin[1][0] = prev_out[2043];
		temp_cin[1][1] = out[2043];
		temp_cin[2][0] = prev_out[1524];
		temp_cin[2][1] = out[1524];
		temp_cin[3][0] = prev_out[1528];
		temp_cin[3][1] = out[1528];
		temp_cin[4][0] = prev_out[1522];
		temp_cin[4][1] = out[1522];
		temp_cout[0][0] = prev_out[2188];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2188] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2189:
		temp_cin[0][0] = prev_out[2130];
		temp_cin[0][1] = out[2130];
		temp_cin[1][0] = prev_out[2044];
		temp_cin[1][1] = out[2044];
		temp_cout[0][0] = prev_out[2189];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2189] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2190:
		temp_cin[0][0] = prev_out[2045];
		temp_cin[0][1] = out[2045];
		temp_cin[1][0] = in_params[48][-1];
		temp_cin[1][1] = in_params[48][0];
		temp_cout[0][0] = prev_out[2190];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2190] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2191:
		temp_cin[0][0] = prev_out[2052];
		temp_cin[0][1] = out[2052];
		temp_cout[0][0] = prev_out[2191];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2191] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2192:
		temp_cin[0][0] = prev_out[2053];
		temp_cin[0][1] = out[2053];
		temp_cout[0][0] = prev_out[2192];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2192] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2193:
		temp_cin[0][0] = prev_out[2046];
		temp_cin[0][1] = out[2046];
		temp_cout[0][0] = prev_out[2193];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2193] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2194:
		temp_cin[0][0] = prev_out[2047];
		temp_cin[0][1] = out[2047];
		temp_cin[1][0] = prev_out[1586];
		temp_cin[1][1] = out[1586];
		temp_cin[2][0] = prev_out[1588];
		temp_cin[2][1] = out[1588];
		temp_cin[3][0] = prev_out[1590];
		temp_cin[3][1] = out[1590];
		temp_cin[4][0] = prev_out[1592];
		temp_cin[4][1] = out[1592];
		temp_cout[0][0] = prev_out[2194];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2194] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2195:
		temp_cin[0][0] = prev_out[2051];
		temp_cin[0][1] = out[2051];
		temp_cin[1][0] = prev_out[2050];
		temp_cin[1][1] = out[2050];
		temp_cin[2][0] = prev_out[2049];
		temp_cin[2][1] = out[2049];
		temp_cin[3][0] = prev_out[2048];
		temp_cin[3][1] = out[2048];
		temp_cout[0][0] = prev_out[2195];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2195] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2196:
		temp_cin[0][0] = prev_out[2053];
		temp_cin[0][1] = out[2053];
		temp_cin[1][0] = prev_out[2052];
		temp_cin[1][1] = out[2052];
		temp_cout[0][0] = prev_out[2196];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2196] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2197:
		temp_cin[0][0] = prev_out[2058];
		temp_cin[0][1] = out[2058];
		temp_cin[1][0] = prev_out[2057];
		temp_cin[1][1] = out[2057];
		temp_cin[2][0] = prev_out[2056];
		temp_cin[2][1] = out[2056];
		temp_cin[3][0] = prev_out[2055];
		temp_cin[3][1] = out[2055];
		temp_cin[4][0] = prev_out[2054];
		temp_cin[4][1] = out[2054];
		temp_cout[0][0] = prev_out[2197];
		and_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2197] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2198:
		temp_cin[0][0] = prev_out[2195];
		temp_cin[0][1] = out[2195];
		temp_cin[1][0] = prev_out[2059];
		temp_cin[1][1] = out[2059];
		temp_cout[0][0] = prev_out[2198];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2198] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2199:
		temp_cin[0][0] = prev_out[2063];
		temp_cin[0][1] = out[2063];
		temp_cin[1][0] = prev_out[2062];
		temp_cin[1][1] = out[2062];
		temp_cin[2][0] = prev_out[2061];
		temp_cin[2][1] = out[2061];
		temp_cin[3][0] = prev_out[2060];
		temp_cin[3][1] = out[2060];
		temp_cout[0][0] = prev_out[2199];
		or_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2199] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2200:
		temp_cin[0][0] = prev_out[2068];
		temp_cin[0][1] = out[2068];
		temp_cin[1][0] = prev_out[2067];
		temp_cin[1][1] = out[2067];
		temp_cin[2][0] = prev_out[2066];
		temp_cin[2][1] = out[2066];
		temp_cin[3][0] = prev_out[2065];
		temp_cin[3][1] = out[2065];
		temp_cin[4][0] = prev_out[2064];
		temp_cin[4][1] = out[2064];
		temp_cout[0][0] = prev_out[2200];
		or_5_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2200] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2201:
		temp_cin[0][0] = prev_out[2069];
		temp_cin[0][1] = out[2069];
		temp_cin[1][0] = prev_out[2071];
		temp_cin[1][1] = out[2071];
		temp_cin[2][0] = prev_out[2073];
		temp_cin[2][1] = out[2073];
		temp_cin[3][0] = prev_out[2075];
		temp_cin[3][1] = out[2075];
		temp_cout[0][0] = prev_out[2201];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2201] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2202:
		temp_cin[0][0] = prev_out[2071];
		temp_cin[0][1] = out[2071];
		temp_cin[1][0] = prev_out[2075];
		temp_cin[1][1] = out[2075];
		temp_cin[2][0] = prev_out[2070];
		temp_cin[2][1] = out[2070];
		temp_cin[3][0] = prev_out[2073];
		temp_cin[3][1] = out[2073];
		temp_cout[0][0] = prev_out[2202];
		and_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2202] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2203:
		temp_cin[0][0] = prev_out[2073];
		temp_cin[0][1] = out[2073];
		temp_cin[1][0] = prev_out[2075];
		temp_cin[1][1] = out[2075];
		temp_cin[2][0] = prev_out[2072];
		temp_cin[2][1] = out[2072];
		temp_cout[0][0] = prev_out[2203];
		and_3_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2203] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2204:
		temp_cin[0][0] = prev_out[2075];
		temp_cin[0][1] = out[2075];
		temp_cin[1][0] = prev_out[2074];
		temp_cin[1][1] = out[2074];
		temp_cout[0][0] = prev_out[2204];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2204] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2205:
		temp_cin[0][0] = prev_out[1228];
		temp_cin[0][1] = out[1228];
		temp_cin[1][0] = prev_out[1178];
		temp_cin[1][1] = out[1178];
		temp_cout[0][0] = prev_out[2205];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2205] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2206:
		temp_cin[0][0] = prev_out[1192];
		temp_cin[0][1] = out[1192];
		temp_cout[0][0] = prev_out[2206];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2206] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2207:
		temp_cin[0][0] = prev_out[1243];
		temp_cin[0][1] = out[1243];
		temp_cout[0][0] = prev_out[2207];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2207] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2208:
		temp_cin[0][0] = prev_out[978];
		temp_cin[0][1] = out[978];
		temp_cout[0][0] = prev_out[2208];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2208] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2209:
		temp_cin[0][0] = prev_out[1019];
		temp_cin[0][1] = out[1019];
		temp_cout[0][0] = prev_out[2209];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2209] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2210:
		temp_cin[0][0] = prev_out[1198];
		temp_cin[0][1] = out[1198];
		temp_cout[0][0] = prev_out[2210];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2210] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2211:
		temp_cin[0][0] = prev_out[1249];
		temp_cin[0][1] = out[1249];
		temp_cout[0][0] = prev_out[2211];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2211] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2212:
		temp_cin[0][0] = prev_out[982];
		temp_cin[0][1] = out[982];
		temp_cout[0][0] = prev_out[2212];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2212] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2213:
		temp_cin[0][0] = prev_out[1025];
		temp_cin[0][1] = out[1025];
		temp_cout[0][0] = prev_out[2213];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2213] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2214:
		temp_cin[0][0] = prev_out[1195];
		temp_cin[0][1] = out[1195];
		temp_cout[0][0] = prev_out[2214];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2214] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2215:
		temp_cin[0][0] = prev_out[1246];
		temp_cin[0][1] = out[1246];
		temp_cout[0][0] = prev_out[2215];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2215] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2216:
		temp_cin[0][0] = in_params[11][-1];
		temp_cin[0][1] = in_params[11][0];
		temp_cout[0][0] = prev_out[2216];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2216] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2217:
		temp_cin[0][0] = in_params[206][-1];
		temp_cin[0][1] = in_params[206][0];
		temp_cin[1][0] = prev_out[2076];
		temp_cin[1][1] = out[2076];
		temp_cout[0][0] = prev_out[2217];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2217] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2218:
		temp_cin[0][0] = prev_out[2217];
		temp_cin[0][1] = out[2217];
		temp_cout[0][0] = prev_out[2218];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2218] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2219:
		temp_cin[0][0] = in_params[11][-1];
		temp_cin[0][1] = in_params[11][0];
		temp_cout[0][0] = prev_out[2219];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2219] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2220:
		temp_cin[0][0] = prev_out[2077];
		temp_cin[0][1] = out[2077];
		temp_cout[0][0] = prev_out[2220];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2220] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2221:
		temp_cin[0][0] = prev_out[2220];
		temp_cin[0][1] = out[2220];
		temp_cout[0][0] = prev_out[2221];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2221] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2222:
		temp_cin[0][0] = prev_out[42];
		temp_cin[0][1] = out[42];
		temp_cout[0][0] = prev_out[2222];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2222] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2223:
		temp_cin[0][0] = prev_out[69];
		temp_cin[0][1] = out[69];
		temp_cout[0][0] = prev_out[2223];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2223] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2224:
		temp_cin[0][0] = prev_out[43];
		temp_cin[0][1] = out[43];
		temp_cout[0][0] = prev_out[2224];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2224] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2225:
		temp_cin[0][0] = prev_out[72];
		temp_cin[0][1] = out[72];
		temp_cout[0][0] = prev_out[2225];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2225] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2226:
		temp_cin[0][0] = prev_out[168];
		temp_cin[0][1] = out[168];
		temp_cout[0][0] = prev_out[2226];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2226] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2227:
		temp_cin[0][0] = prev_out[201];
		temp_cin[0][1] = out[201];
		temp_cout[0][0] = prev_out[2227];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2227] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2228:
		temp_cin[0][0] = prev_out[568];
		temp_cin[0][1] = out[568];
		temp_cout[0][0] = prev_out[2228];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2228] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2229:
		temp_cin[0][0] = prev_out[620];
		temp_cin[0][1] = out[620];
		temp_cout[0][0] = prev_out[2229];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2229] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2230:
		temp_cin[0][0] = prev_out[2079];
		temp_cin[0][1] = out[2079];
		temp_cin[1][0] = prev_out[2078];
		temp_cin[1][1] = out[2078];
		temp_cout[0][0] = prev_out[2230];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2230] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2231:
		temp_cin[0][0] = in_params[205][-1];
		temp_cin[0][1] = in_params[205][0];
		temp_cout[0][0] = prev_out[2231];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2231] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2232:
		temp_cin[0][0] = prev_out[2080];
		temp_cin[0][1] = out[2080];
		temp_cout[0][0] = prev_out[2232];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2232] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2233:
		temp_cin[0][0] = prev_out[1615];
		temp_cin[0][1] = out[1615];
		temp_cin[1][0] = prev_out[2081];
		temp_cin[1][1] = out[2081];
		temp_cout[0][0] = prev_out[2233];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2233] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2234:
		temp_cin[0][0] = prev_out[2083];
		temp_cin[0][1] = out[2083];
		temp_cin[1][0] = prev_out[2082];
		temp_cin[1][1] = out[2082];
		temp_cout[0][0] = prev_out[2234];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2234] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2235:
		temp_cin[0][0] = prev_out[446];
		temp_cin[0][1] = out[446];
		temp_cin[1][0] = prev_out[2084];
		temp_cin[1][1] = out[2084];
		temp_cout[0][0] = prev_out[2235];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2235] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2236:
		temp_cin[0][0] = prev_out[2086];
		temp_cin[0][1] = out[2086];
		temp_cin[1][0] = prev_out[2085];
		temp_cin[1][1] = out[2085];
		temp_cout[0][0] = prev_out[2236];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2236] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2237:
		temp_cin[0][0] = prev_out[446];
		temp_cin[0][1] = out[446];
		temp_cin[1][0] = prev_out[2087];
		temp_cin[1][1] = out[2087];
		temp_cout[0][0] = prev_out[2237];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2237] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2238:
		temp_cin[0][0] = prev_out[2089];
		temp_cin[0][1] = out[2089];
		temp_cin[1][0] = prev_out[2088];
		temp_cin[1][1] = out[2088];
		temp_cout[0][0] = prev_out[2238];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2238] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2239:
		temp_cin[0][0] = prev_out[2091];
		temp_cin[0][1] = out[2091];
		temp_cin[1][0] = prev_out[2090];
		temp_cin[1][1] = out[2090];
		temp_cout[0][0] = prev_out[2239];
		or_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2239] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2240:
		temp_cin[0][0] = prev_out[2239];
		temp_cin[0][1] = out[2239];
		temp_cout[0][0] = prev_out[2240];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2240] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2241:
		temp_cin[0][0] = prev_out[2092];
		temp_cin[0][1] = out[2092];
		temp_cout[0][0] = prev_out[2241];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2241] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2242:
		temp_cin[0][0] = prev_out[2094];
		temp_cin[0][1] = out[2094];
		temp_cin[1][0] = prev_out[2093];
		temp_cin[1][1] = out[2093];
		temp_cout[0][0] = prev_out[2242];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2242] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2243:
		temp_cin[0][0] = prev_out[2096];
		temp_cin[0][1] = out[2096];
		temp_cin[1][0] = prev_out[2095];
		temp_cin[1][1] = out[2095];
		temp_cout[0][0] = prev_out[2243];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2243] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2244:
		temp_cin[0][0] = prev_out[454];
		temp_cin[0][1] = out[454];
		temp_cin[1][0] = prev_out[2097];
		temp_cin[1][1] = out[2097];
		temp_cout[0][0] = prev_out[2244];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2244] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2245:
		temp_cin[0][0] = prev_out[2099];
		temp_cin[0][1] = out[2099];
		temp_cin[1][0] = prev_out[2098];
		temp_cin[1][1] = out[2098];
		temp_cout[0][0] = prev_out[2245];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2245] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2246:
		temp_cin[0][0] = prev_out[454];
		temp_cin[0][1] = out[454];
		temp_cin[1][0] = prev_out[2100];
		temp_cin[1][1] = out[2100];
		temp_cout[0][0] = prev_out[2246];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2246] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2247:
		temp_cin[0][0] = prev_out[2102];
		temp_cin[0][1] = out[2102];
		temp_cin[1][0] = prev_out[2101];
		temp_cin[1][1] = out[2101];
		temp_cout[0][0] = prev_out[2247];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2247] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2248:
		temp_cin[0][0] = prev_out[2106];
		temp_cin[0][1] = out[2106];
		temp_cin[1][0] = prev_out[2105];
		temp_cin[1][1] = out[2105];
		temp_cin[2][0] = prev_out[2104];
		temp_cin[2][1] = out[2104];
		temp_cin[3][0] = prev_out[2103];
		temp_cin[3][1] = out[2103];
		temp_cout[0][0] = prev_out[2248];
		or_4_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2248] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2249:
		temp_cin[0][0] = prev_out[2248];
		temp_cin[0][1] = out[2248];
		temp_cout[0][0] = prev_out[2249];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2249] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2250:
		temp_cin[0][0] = prev_out[2107];
		temp_cin[0][1] = out[2107];
		temp_cout[0][0] = prev_out[2250];
		not_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2250] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2251:
		temp_cin[0][0] = prev_out[2109];
		temp_cin[0][1] = out[2109];
		temp_cin[1][0] = prev_out[2108];
		temp_cin[1][1] = out[2108];
		temp_cout[0][0] = prev_out[2251];
		and_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2251] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2252:
		temp_cin[0][0] = prev_out[2111];
		temp_cin[0][1] = out[2111];
		temp_cin[1][0] = prev_out[2110];
		temp_cin[1][1] = out[2110];
		temp_cout[0][0] = prev_out[2252];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2252] = *(cout_ptr[0]);
		(*sym)++;
		break;

	 
	case 2253:
		temp_cin[0][0] = prev_out[574];
		temp_cin[0][1] = out[574];
		temp_cin[1][0] = prev_out[2112];
		temp_cin[1][1] = out[2112];
		temp_cout[0][0] = prev_out[2253];
		nand_2_inject(fault_no, vecnt, cin_ptr, cout_ptr);
		out[2253] = *(cout_ptr[0]);
		(*sym)++;
		break;

	default:
		;
	}
}