typedef struct
{
	uint64_t channel_fail_codes[19];
}FAILURE_CODES;

FAILURE_CODES unit_failure_code[4];

void show() {
	printf("UNIT\tCHAN\tCODE\n");
	for(size_t u = 0; u != sizeof(unit_failure_code) / sizeof(FAILURE_CODES); u++) {
		for(size_t c = 0; c != sizeof(FAILURE_CODES::channel_fail_codes) / sizeof(uint64_t); c++) {
			uint64_t data = unit_failure_code[u].channel_fail_codes[c];
			if (data != 0) { // есть ошибки
				uint64_t mask = 1;
				for (size_t e = 0; e != 64; e++) {
					if ((data & mask) != 0) printf("%d\t%d\t%d\n", u, c, e);
					mask <<= 1;
				}
			}
		}
	}
}

int main()
{
	unit_failure_code[3].channel_fail_codes[1] = 0x24;
	show();
}

state = State.UNIT_NUM;

unit[3].not_empty = true;

unit[3].channel_code[2] = 0x85;
            //3 2 0
            //3 2 2
            //3 2 7
unit[3].channel_code[4] = 0x18;
            //3 4 3
            //3 4 4

 private void buttonUp_Click(object sender, EventArgs e)
{
        BrowseFailCodes(UP);
}

private void buttonDown_Click(object sender, EventArgs e)
{
       BrowseFailCodes(DOWN); 
}

void BrowseFailCodes(int direction)
        {
            uint idx;

            if (state == State.UNIT_NUM)
            {
                if (direction == UP)
                    {
                    for (idx = next_unit_num; idx < 4; idx++)
                    {
                        //there are some channels with fail codes
                        if (unit[idx].not_empty)
                        {
                            unit_num = idx;

                            next_unit_num = idx + 1;
                            if (next_unit_num > 3)
                                next_unit_num = 0;

                            next_chan_num = 0;

                            state = State.CHAN_NUM;
                            break;
                        }
                    }
                }
            }

            if (state == State.CHAN_NUM)
            {
                if (direction == UP)
                {
                    for (idx = next_chan_num; idx < 19; idx++)
                    {
                        //there are some fail codes in the tube
                        if (unit[unit_num].channel_code[idx] > 0)
                        {
                            chan_num = idx;

                            next_chan_num = idx + 1;
                            //got ot the end - next unit
                            if (next_chan_num > 18)
                            {
                                next_chan_num = 0;
                                state = State.UNIT_NUM;
                            }

                            next_code_num = 0;

                            code_val = unit[unit_num].channel_code[chan_num];

                            state = State.CODE_NUM;
                            break;
                        }
                    }
                }
            }

            if (state == State.CODE_NUM)
            {
                if (direction == UP)
                {
                    //get next failure code
                    for (idx = next_code_num; idx < 64; idx++)
                    {
                        //fail code found
                        if ((code_val & 0x01) == 1)
                        {
                            code_num = idx;
                            next_code_num = idx + 1;
                            if (next_code_num > 63)
                            {
                                next_code_num = 0;

                                state = State.CHAN_NUM;
                                break;
                            }

                            //display the failure code
                            state = State.DISPLAY;
                            break;
                        }
                        else
                        {
                            code_val >>= 1;
                            next_code_num++;
                            //got to the end - next channel
                            if (next_code_num > 63)
                            {
                                next_code_num = 0;

                                state = State.CHAN_NUM;
                                break;
                            }
                        }
                    }
                }
            }

            if (state == State.DISPLAY)
            {
                textBoxPgrlNum.Text = unit_num.ToString();
                textBoxTubeNum.Text = chan_num.ToString();
                textBoxCodeNum.Text = code_num.ToString();

                code_val >>= 1;

                state = State.CODE_NUM;
            }

        }

typedef struct {
	int u;
	int c;
	int e;
} ONE_ERROR;

void error_init(ONE_ERROR *e) {
	e->u = -1;
}

bool error_next(ONE_ERROR *e) {
	if(e->u == -1) {
		e->u = 0;
		e->c = 0;
		e->e = 0;
	} else {
		e->e++;
	}
	for (; e->u != sizeof(unit_failure_code) / sizeof(FAILURE_CODES); e->u++) {
		for (; e->c != sizeof(FAILURE_CODES::channel_fail_codes) / sizeof(uint64_t); e->c++) {
			uint64_t data = unit_failure_code[e->u].channel_fail_codes[e->c];
			if (data != 0) { // есть ошибки
				uint64_t mask = 1<<(e->e);
				for (; e->e != 64; e->e++) {
					if ((data & mask) != 0) return true;
					mask <<= 1;
				}
			}
			e->e = 0;
		}
		e->c = 0;
	}
	return false;
}

void show2() {
	printf("UNIT\tCHAN\tCODE\n");
	ONE_ERROR e;
	error_init(&e);
	while(error_next(&e))  printf("%d\t%d\t%d\n", e.u, e.c, e.e);
}

int main()
{
	unit_failure_code[3].channel_fail_codes[2] = 0x85;
	unit_failure_code[3].channel_fail_codes[4] = 0x18;
	show2();
}