void sgen_run_generator(struct sgen_generator *g, struct codec *c, sample_t *buf, ssize_t frames)
{
	sample_t s;
	double t;
	ssize_t i, k, samples;
	switch (g->type) {
	case SGEN_TYPE_DELTA:
		if (g->offset >= 0) {
			if (g->offset < frames)
				for (i = 0; i < c->channels; ++i)
					if (GET_BIT(g->channel_selector, i))
						buf[g->offset * c->channels + i] += 1.0;
			g->offset -= frames;
		}
		break;
	case SGEN_TYPE_SINE:
		samples = frames * c->channels;
		for (i = 0; i < samples; i += c->channels) {
			t = (double) g->pos / c->fs;
			if (g->v != 0.0)
				s = sin(g->freq0 / g->v * (exp(t * g->v) - 1.0));
			else
				s = sin(g->freq0 * t);
			for (k = 0; k < c->channels; ++k)
				if (GET_BIT(g->channel_selector, k))
					buf[i + k] += s;
			++g->pos;
		}
		break;
	}
}

/*
 * Boot module scope
 */
int
app_preload(struct app_t *app, int argc, char **argv)
{
	struct module_t *module = app->data;
	struct app_opt_t *app_opt;

	if(NULL == module)
		return E_MOD;

	app_opt = app->opts;
	log(app->ctx,1,"app preload: %s\n", module->name);

	/* Must be boot type */
	if(!GET_BIT(module->type, M_BOOT))
		return E_CONF;

	if(!GET_BIT(module->type, M_EMBED))
		log(app->ctx, 1, "Warn: app module not embedded!\n");

	app->ctx->boot->module = module;

	if(module->preload(app->ctx, app->ctx->boot))
		return E_CONF;

	/* Now register app and we are ready to go */
	if(!register_app(app->ctx, app))
		return E_CONF;

	return E_NONE;
}

/**
 * Calculates the heuristic score for the AI
 */
heuristic_t calculate_heuristics(int isItSelfTurn) {
    // Turn bonus
    heuristic_t score = (isItSelfTurn << 3) - (isItSelfTurn << 1) - 3; //isItSelfTurn*6-3

    // Material + king bonus
    score += population_score();

    // Runaway man
    /*score += ((0x00000010 & (gamestate.self & (~gamestate.kings))) && !(0x00000001 & gamestate.occupied)) * 47;
    score -= ((0x01000000 & (gamestate.other & (~gamestate.kings))) && !(0x30000000 & gamestate.occupied)) * 47;
    score += ((0x00000020 & (gamestate.self & (~gamestate.kings))) && !(0x00000003 & gamestate.occupied)) * 47;
    score -= ((0x02000000 & (gamestate.other & (~gamestate.kings))) && !(0x60000000 & gamestate.occupied)) * 47;
    score += ((0x00000040 & (gamestate.self & (~gamestate.kings))) && !(0x00000006 & gamestate.occupied)) * 47;
    score -= ((0x04000000 & (gamestate.other & (~gamestate.kings))) && !(0xC0000000 & gamestate.occupied)) * 47;
    score += ((0x00000080 & (gamestate.self & (~gamestate.kings))) && !(0x0000000C & gamestate.occupied)) * 47;
    score -= ((0x08000000 & (gamestate.other & (~gamestate.kings))) && !(0x80000000 & gamestate.occupied)) * 47;
    score += ((0x00000100 & (gamestate.self & (~gamestate.kings))) && !(0x00000011 & gamestate.occupied)) * 44;
    score -= ((0x00100000 & (gamestate.other & (~gamestate.kings))) && !(0x31000000 & gamestate.occupied)) * 44;
    score += ((0x00000200 & (gamestate.self & (~gamestate.kings))) && !(0x00000067 & gamestate.occupied)) * 44;
    score -= ((0x00200000 & (gamestate.other & (~gamestate.kings))) && !(0x73000000 & gamestate.occupied)) * 44;
    score += ((0x00000400 & (gamestate.self & (~gamestate.kings))) && !(0x000000CE & gamestate.occupied)) * 44;
    score -= ((0x00400000 & (gamestate.other & (~gamestate.kings))) && !(0xE6000000 & gamestate.occupied)) * 44;
    score += ((0x00000800 & (gamestate.self & (~gamestate.kings))) && !(0x0000008C & gamestate.occupied)) * 44;
    score -= ((0x00800000 & (gamestate.other & (~gamestate.kings))) && !(0x88000000 & gamestate.occupied)) * 44;*/

    // Back row bonus
    score += population_count(0xF0000000 & gamestate.occupied) * 7;
    score -= population_count(0x0000000F & gamestate.occupied) * 7;

    // Dog hole penalty
    score += (GET_BIT(gamestate.other, 27) && GET_BIT(gamestate.self, 31)) * 10;
    score -= (GET_BIT(gamestate.self, 4) && GET_BIT(gamestate.other, 0)) * 10;

    return score;
}

void compress_effect_run(struct effect *e, ssize_t *frames, sample_t *ibuf, sample_t *obuf)
{
    ssize_t i, k, samples = *frames * e->ostream.channels;
    sample_t s, gain_target;
    struct compress_state *state = (struct compress_state *) e->data;
    for (i = 0; i < samples; i += e->ostream.channels) {
        s = 0;
        for (k = 0; k < e->ostream.channels; ++k)
            if (GET_BIT(e->channel_selector, k))
                s = MAXIMUM(fabs(ibuf[i + k]), s);
        if (s > state->thresh)
            gain_target = pow(10, (state->thresh_db - (20 * log10(s))) * state->ratio / 20);
        else
            gain_target = 1.0;
        if (state->gain > gain_target) {
            state->gain *= state->attack;
            if (state->gain < gain_target)
                state->gain = gain_target;
        }
        else if (state->gain < gain_target) {
            state->gain *= state->release;
            if (state->gain > gain_target)
                state->gain = gain_target;
        }
        for (k = 0; k < e->ostream.channels; ++k) {
            if (GET_BIT(e->channel_selector, k))
                obuf[i + k] = ibuf[i + k] * state->gain;
            else
                obuf[i + k] = ibuf[i + k];
        }
    }
}

void controlBrakePostfire(int hasEventFlags, int craneKnownFlags, 
        int cranePresentFlags) {

    switch(state) {
        case READY : {
            if(GET_BIT(craneKnownFlags, TRIGGERBIT)) {
                if(GET_BIT(cranePresentFlags, TRIGGERBIT)) {
                    state = RUNNING;
                }
            }
        } break;

        case RUNNING : {
            if(GET_BIT(hasEventFlags, SHUTDOWNBIT)) {
                initControlBrake();
                break;
            }

            if(GET_BIT(craneKnownFlags, EMSTOPMERGERBIT)) {
                if(GET_BIT(cranePresentFlags, EMSTOPMERGERBIT)) {
                    initControlBrake();
                }
            }
        } break;
    }
}

int key_pressed(r,c) {
	if (!GET_BIT(PINC, r)) {
		if (!GET_BIT(PORTC, c))
		return 1;
	}
	return 0;
}

Board captureLine(Board b, int moveIndex, int player, short dX, short dY) {
	Board bc = b;
	while ( 1 ) {
		// Left side out of bounds
		if( dX < 0 && moveIndex % 8 == 0) {
			return b;
		}
		// Right side out of bounds
		if ( dX > 0 && moveIndex % 8 == 7) {
			return b;
		}
		moveIndex += dX + dY * 8;
		// Upper edge & lower edge out of bounds
		if ( moveIndex < 0 || moveIndex > 63 ) {
			return b;
		}
		else if ( ! GET_BIT(b.mask, moveIndex) ) {
			return b;
		}
		else if ( GET_BIT(b.owner, moveIndex) ^ player){
			bc.owner = TOGGLE_BIT(bc.owner, moveIndex);
		}
		else {
			return bc;
		}
	}
	return b; // Never reached, included for compiler warnings
}

/* returns 0 if bmsk and src dont match, 1 if they do */
int
convCmp_bitMask(Byte bmsk, Byte src, int istart, int iend)
{
    int ret = 1;
    if (!iend) {
        /* if there's only one index number to check (iend = 0) */
	if (GET_BIT(bmsk, 0) != GET_BIT(src, istart)) {
	    return 0;
	}
        else {
            return 1;
	}
    }
    /* if there's a group of index numbers to check */
    else {
	int i, x;
        for (i = istart, x = 0; i < iend; i++, x++) {
            if (GET_BIT(src, i) != GET_BIT(bmsk, x)) {
                ret = 0;
                break;
            }
        }
    }
    return ret;
}

_Bool pressed(int col, int row)
{
	CLR_BIT(PORTC, col);
	_Bool buttonPressed = !GET_BIT(PINC, col) && !GET_BIT(PINC, row);
	
	return !GET_BIT(PINC, col) && !GET_BIT(PINC, row);
}

/*
 * Boot.
 * Squat app/module is using it
 */
struct ctx_t *
app_boot(struct ctx_t *cur, void *a, void *args)
{
	app_getopt *opts = args;
	struct app_t *app = a;
	struct cfg_t *cfg;

	if(NULL == cur)
	{
		if(app->ctx)
			log(app->ctx, 1, "Alredy got app->ctx!\n");

		app->ctx = ctx_new(CTX_STDERR|CTX_BOOT);

		if (NULL == app->ctx)
			return NULL;
	}
	else
		app->ctx = cur;

	cfg = app->ctx->cfg;
	set_early_log(app->ctx);

	/* Ok we really really need this very early */
	if(NULL == sys_create(app->ctx, "api", T_HASH))
		return NULL;

	/*if(NULL == sys_create(app->ctx, "parser", T_STORE))
		return NULL;*/

	log(app->ctx, 0, "app boot: %s\n", app->name);

	/*
	 * Default handler is sig_run
	 * sig_run is responsible of traversing ctx/scope
	 * and run all handlers that are registered
	 */
	/*signal(SIGINT, sig_run);
	signal(SIGHUP, sig_run);
	signal(SIGTERM, sig_run);
	signal(SIGSEGV, sig_run);
	signal(SIGBUS, sig_run);*/

	/* reset to default boot options */
	if(GET_BIT(app->type, APP_DAEMON))
		cfg->basic->daemon = 1;

	if(GET_BIT(app->type, APP_LOG))
		cfg->basic->prio = 1;

	/* cfg */
	cfg->basic->argc = opts->argc;
	cfg->basic->argv = opts->argv;

	optind = 1;
	return app->ctx;
}

static void rewrite_source(struct radeon_compiler * c,
		struct rc_instruction * inst, unsigned src)
{
	struct rc_swizzle_split split;
	unsigned int tempreg = rc_find_free_temporary(c);
	unsigned int usemask;

	usemask = 0;
	for(unsigned int chan = 0; chan < 4; ++chan) {
		if (GET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan) != RC_SWIZZLE_UNUSED)
			usemask |= 1 << chan;
	}

	c->SwizzleCaps->Split(inst->U.I.SrcReg[src], usemask, &split);

	for(unsigned int phase = 0; phase < split.NumPhases; ++phase) {
		struct rc_instruction * mov = rc_insert_new_instruction(c, inst->Prev);
		unsigned int phase_refmask;
		unsigned int masked_negate;

		mov->U.I.Opcode = RC_OPCODE_MOV;
		mov->U.I.DstReg.File = RC_FILE_TEMPORARY;
		mov->U.I.DstReg.Index = tempreg;
		mov->U.I.DstReg.WriteMask = split.Phase[phase];
		mov->U.I.SrcReg[0] = inst->U.I.SrcReg[src];
		mov->U.I.PreSub = inst->U.I.PreSub;

		phase_refmask = 0;
		for(unsigned int chan = 0; chan < 4; ++chan) {
			if (!GET_BIT(split.Phase[phase], chan))
				SET_SWZ(mov->U.I.SrcReg[0].Swizzle, chan, RC_SWIZZLE_UNUSED);
			else
				phase_refmask |= 1 << GET_SWZ(mov->U.I.SrcReg[0].Swizzle, chan);
		}

		phase_refmask &= RC_MASK_XYZW;

		masked_negate = split.Phase[phase] & mov->U.I.SrcReg[0].Negate;
		if (masked_negate == 0)
			mov->U.I.SrcReg[0].Negate = 0;
		else if (masked_negate == split.Phase[phase])
			mov->U.I.SrcReg[0].Negate = RC_MASK_XYZW;

	}

	inst->U.I.SrcReg[src].File = RC_FILE_TEMPORARY;
	inst->U.I.SrcReg[src].Index = tempreg;
	inst->U.I.SrcReg[src].Swizzle = 0;
	inst->U.I.SrcReg[src].Negate = RC_MASK_NONE;
	inst->U.I.SrcReg[src].Abs = 0;
	for(unsigned int chan = 0; chan < 4; ++chan) {
		SET_SWZ(inst->U.I.SrcReg[src].Swizzle, chan,
				GET_BIT(usemask, chan) ? chan : RC_SWIZZLE_UNUSED);
	}
}

void perm_to_str(int perm, char str[4])
{
    strcpy(str, "rwx");

    if(GET_BIT(perm, 2) == 0)
        str[0] = '-';

    if(GET_BIT(perm, 1) == 0)
        str[1] = '-';

    if(GET_BIT(perm, 0) == 0)
        str[2] = '-';
}

int read_pagemap(char * path_buf, unsigned long virt_addr){
   printf("Big endian? %d\n", is_bigendian());
   f = fopen(path_buf, "rb");
   if(!f){
      printf("Error! Cannot open %s\n", path_buf);
      return -1;
   }
   
   //Shifting by virt-addr-offset number of bytes
   //and multiplying by the size of an address (the size of an entry in pagemap file)
   file_offset = virt_addr / getpagesize() * PAGEMAP_ENTRY;
   printf("Vaddr: 0x%lx, Page_size: %d, Entry_size: %d\n", virt_addr, getpagesize(), PAGEMAP_ENTRY);
   printf("Reading %s at 0x%llx\n", path_buf, (unsigned long long) file_offset);
   status = fseek(f, file_offset, SEEK_SET);
   if(status){
      perror("Failed to do fseek!");
      return -1;
   }
   errno = 0;
   read_val = 0;
   unsigned char c_buf[PAGEMAP_ENTRY];
   for(i=0; i < PAGEMAP_ENTRY; i++){
      c = getc(f);
      if(c==EOF){
         printf("\nReached end of the file\n");
         return 0;
      }
      if(is_bigendian())
           c_buf[i] = c;
      else
           c_buf[PAGEMAP_ENTRY - i - 1] = c;
      printf("[%d]0x%x ", i, c);
   }
   for(i=0; i < PAGEMAP_ENTRY; i++){
      //printf("%d ",c_buf[i]);
      read_val = (read_val << 8) + c_buf[i];
   }
   printf("\n");
   printf("Result: 0x%llx\n", (unsigned long long) read_val);
   //if(GET_BIT(read_val, 63))
   if(GET_BIT(read_val, 63))
      printf("PFN: 0x%llx\n",(unsigned long long) GET_PFN(read_val));
   else
      printf("Page not present\n");
   if(GET_BIT(read_val, 62))
      printf("Page swapped\n");
   fclose(f);
   return 0;
}

static void plot_rfi(rfi * plotrfi, float top, int numint, int numchan,
                     float T, float lof, float hif)
{
   int ii;
   float period, perioderr, dy = 0.035, *temparr;
   float tr[6] = { -0.5, 1.0, 0.0, -0.5, 0.0, 1.0 };
   char temp[40];

   if (plotrfi->freq_avg == 0.0)
      period = 0.0;
   else
      period = 1000.0 / plotrfi->freq_avg;
   if (plotrfi->freq_var == 0.0)        /* Why are these zero? */
      perioderr = 0.0;
   else
      perioderr = 1000.0 * sqrt(plotrfi->freq_var) /
          (plotrfi->freq_avg * plotrfi->freq_avg);
   cpgsvp(0.0, 1.0, 0.0, 1.0);
   cpgswin(0.0, 1.0, 0.0, 1.0);
   cpgnice_output_2(temp, plotrfi->freq_avg, sqrt(plotrfi->freq_var), 0);
   cpgptxt(0.03, top - 0.6 * dy, 0.0, 0.0, temp);
   cpgnice_output_2(temp, period, perioderr, 0);
   cpgptxt(0.12, top - 0.6 * dy, 0.0, 0.0, temp);
   sprintf(temp, "%-5.2f", plotrfi->sigma_avg);
   cpgptxt(0.21, top - 0.6 * dy, 0.0, 0.0, temp);
   sprintf(temp, "%d", plotrfi->numobs);
   cpgptxt(0.27, top - 0.6 * dy, 0.0, 0.0, temp);
   ii = (numint > numchan) ? numint : numchan;
   temparr = gen_fvect(ii);
   for (ii = 0; ii < numchan; ii++)
      temparr[ii] = GET_BIT(plotrfi->chans, ii);
   cpgsvp(0.33, 0.64, top - dy, top);
   cpgswin(0.0, numchan, 0.0, 1.0);
   cpgimag(temparr, numchan, 1, 1, numchan, 1, 1, 0.0, 1.0, tr);
   cpgswin(0.0, numchan, 0.0, 1.0);
   cpgbox("BST", 0.0, 0, "BC", 0.0, 0);
   cpgswin(lof, hif, 0.0, 1.0);
   cpgbox("CST", 0.0, 0, "", 0.0, 0);
   for (ii = 0; ii < numint; ii++)
      temparr[ii] = GET_BIT(plotrfi->times, ii);
   cpgsvp(0.65, 0.96, top - dy, top);
   cpgswin(0.0, numint, 0.0, 1.0);
   cpgimag(temparr, numint, 1, 1, numint, 1, 1, 0.0, 1.0, tr);
   cpgswin(0.0, numint, 0.0, 1.0);
   cpgbox("BST", 0.0, 0, "BC", 0.0, 0);
   cpgswin(0.0, T, 0.0, 1.0);
   cpgbox("CST", 0.0, 0, "", 0.0, 0);
   vect_free(temparr);
}

int preprocess_it(Instruction *out, Emulator *emul)
{
	char msk = (char) out->ext.plages[0].value;
	int mask=0, sign=0, thn=out->ext.plages[1].value, els=0;
	int i, k;
	char cond0 = GET_BIT(thn, 0);


	for (k = 0; k < 4; k++) // trouve le premier bit à 1
	{
		if(GET_BIT(msk, k) == (1 << k) )
			break;
	}



	for (i = 3; i > k; i--)
	{
		if( GET_BIT(msk, i) == (cond0 << i) )
		{
			strcat(out->name_out, "T");
			sign += (sign << 1) + 1;
		}
		else
		{
			strcat(out->name_out, "E");
			sign <<= 1;
		}
	}

	strcat(out->name_out, " ");
	strcat(out->name_out, emul->dic->states_tab[thn]);


	mask = (1 << (4 - k)) - 1; // mask au format de la fonction process_state
	sign += (sign << 1) + 1; // la première condition est forcément Then

	// printf("k = %u\tmask = %s\n", k, int_to_bin(mask, 4));

	if( (thn & 1) == 0 )
		els = thn + 1;
	else
		els = thn - 1;

	set_it_state(&emul->it_state, mask, sign, thn, els);

	return 0;
}

// Encodes a frame according to the following rule:
// First byte : Start sequence = 1111 1111 (0xFF)
// Second byte : Total size of the encoded frame
// The starting sequence cannot be repeated in the rest of the encoded frame, so
// a 0 (zero) is interleaved every 7 consecutive 1s (ex: 1111 1111 is encoded to 1111 1110 1000)
uint8_t * DataLinkLayer::frame_encode(Frame * frame, uint8_t * size) {
    uint8_t * data = (uint8_t *) frame;
    uint32_t consecutive_ones = 0;
    uint32_t total_extra_bits = 0;
    uint32_t bit_number = 0;

    // Calculate the necessary extra bits to encode the frame
    for(int i = 0; i < sizeof(*frame) * 8; i++) {
        if (GET_BIT(data, i)) {
            consecutive_ones++;
            if (consecutive_ones == 8) {
                total_extra_bits++;
                consecutive_ones = 1;
            }
        } else {
            consecutive_ones = 0;
        }
    }

    // Allocate the necessary space for the encoded frame
    // The size the total size of the frame plus the necessary bytes for the extra bits
    uint32_t alloc_size = sizeof(*frame) + (total_extra_bits ? (total_extra_bits / 8) + 1 : 0);
    uint8_t * result = (uint8_t *) calloc(alloc_size + 2, sizeof(uint8_t));

    // Set the frame start byte
    *result = FRAME_START_BYTE;
    // Set the total allocation size
    *(result + 1) = alloc_size;
    consecutive_ones = 0;

    // Encodes the frame interleaving a zero every 7 consecutive ones
    for(int i = 0; i < sizeof(*frame) * 8; i++, bit_number++) {
        uint8_t current_bit = GET_BIT(data, i);
        if (current_bit) {
            consecutive_ones++;
            if (consecutive_ones == 8) {
                bit_number++;
                consecutive_ones = 1;
            }
        } else {
            consecutive_ones = 0;
        }
        *(result + 2 + (bit_number / 8)) |= (current_bit << (8 - (bit_number % 8) - 1));
    }

    *size = alloc_size + 2;
    return result;
}

static void reads_normal(struct rc_instruction * fullinst, rc_read_write_fn cb, void * userdata)
{
	struct rc_sub_instruction * inst = &fullinst->U.I;
	const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->Opcode);

	for(unsigned int src = 0; src < opcode->NumSrcRegs; ++src) {
		unsigned int refmask = 0;

		if (inst->SrcReg[src].File == RC_FILE_NONE)
			return;

		for(unsigned int chan = 0; chan < 4; ++chan)
			refmask |= 1 << GET_SWZ(inst->SrcReg[src].Swizzle, chan);

		refmask &= RC_MASK_XYZW;

		for(unsigned int chan = 0; chan < 4; ++chan) {
			if (GET_BIT(refmask, chan)) {
				cb(userdata, fullinst, inst->SrcReg[src].File, inst->SrcReg[src].Index, chan);
			}
		}

		if (refmask && inst->SrcReg[src].RelAddr)
			cb(userdata, fullinst, RC_FILE_ADDRESS, 0, RC_MASK_X);
	}
}

status_t
submit_tx_command(bt_usb_dev* bdev, snet_buffer* snbuf)
{
	uint8 bRequestType = bdev->ctrl_req;
	uint8 bRequest = 0;
	uint16 wIndex = 0;
	uint16 value = 0;
	uint16 wLength = B_HOST_TO_LENDIAN_INT16(snb_size(snbuf));
	status_t error;

	if (!GET_BIT(bdev->state, RUNNING)) {
		return B_DEV_NOT_READY;
	}

	// set cookie
	snb_set_cookie(snbuf, bdev);

	debugf("@%p\n", snb_get(snbuf));

	error = usb->queue_request(bdev->dev, bRequestType, bRequest,
		value, wIndex, wLength,	snb_get(snbuf),
#ifndef HAIKU_TARGET_PLATFORM_HAIKU
		wLength,
#endif
		command_complete, (void*) snbuf);

	if (error != B_OK) {
		bdev->stat.rejectedTX++;
	} else {
		bdev->stat.acceptedTX++;
	}

	return error;
}

status_t
submit_tx_acl(bt_usb_dev* bdev, net_buffer* nbuf)
{
	status_t error;

	// set cookie
	SET_DEVICE(nbuf, bdev->hdev);

	if (!GET_BIT(bdev->state, RUNNING)) {
		return B_DEV_NOT_READY;
	}
	/*
	debugf("### Outgoing ACL: len = %ld\n", nbuf->size);
	for (uint32 index = 0 ; index < nbuf->size; index++ ) {
		dprintf("%x:",((uint8*)nb_get_whole_buffer(nbuf))[index]);
	}
	*/

	error = usb->queue_bulk(bdev->bulk_out_ep->handle, nb_get_whole_buffer(nbuf),
		nbuf->size, acl_tx_complete, (void*)nbuf);

	if (error != B_OK) {
		bdev->stat.rejectedTX++;
	} else {
		bdev->stat.acceptedTX++;
	}

	return error;
}

/**********************************************************************************
函数功能：点亮或者熄灭某一个显示标志
入口：    Flag----1:显示;0:熄灭
出口：    1---------有此设备；0------找不到设备
**********************************************************************************/
INT8U SetOrClr_COM4(INT16U Seg,INT8U Com,INT8U Type,INT8U ClrOrSet)
{
   
  if((Seg<=MAX_SEG)&&(Com<=MAX_COL))
  {
    Com=MAX_COL-Com;
    if(Seg%2 EQ 0)       //高4位
        Com+=MAX_COL+1;
      
    if(ClrOrSet)
    {
      if(GET_BIT(Show_Lcd_Ram[Seg/2],Com))  //检查内存是否已经置位或者 seg/com配置表错误
      return 0;
      
      Show_Lcd_Flag=1;       
      
      SET_BIT(Show_Lcd_Ram[Seg/2],Com);
      return 1;
    }
    else
    {        
      CLR_BIT(Show_Lcd_Ram[Seg/2],Com);
      return 1;
    }  
  }
  return 0;
}