int JComplexData::compareTo(const JObject& s) const {
  if (className() != s.className())
    return JObject::compareTo(s);
  return cmp(value.norm(), ((JComplexData*)&s)->value.norm());
}

/* Сравнение 2-х строк
 * s > p  |  1
 * s = p  |  0
 * s < p  |  -1   */
int cmp(char *s, char *p)
{
	return *s ? *p ? *s == *p ? cmp(++s, ++p) : *s > *p ? 1 : -1 : 1 : *p ? -1 : 0; // 53
}

int CollateJSON(const sized_buf *buf1,
                const sized_buf *buf2,
                CollateJSONMode mode)
{
    const char* str1 = buf1->buf;
    const char* str2 = buf2->buf;
    int depth = 0;

    do {
        /* Get the types of the next token in each string: */
        ValueType type1 = valueTypeOf(*str1);
        ValueType type2 = valueTypeOf(*str2);
        /* If types don't match, stop and return their relative ordering: */
        if (type1 != type2) {
            if (mode != kCollateJSON_Raw)
                return cmp(type1, type2);
            else
                return cmp(kRawOrderOfValueType[type1], kRawOrderOfValueType[type2]);

        /* If types match, compare the actual token values: */
        } else switch (type1) {
            case kNull:
            case kTrue:
                str1 += 4;
                str2 += 4;
                break;
            case kFalse:
                str1 += 5;
                str2 += 5;
                break;
            case kNumber: {
                char* next1, *next2;
                int diff;
                if (depth == 0) {
                    /* At depth 0, be careful not to fall off the end of the
                       input, because there won't be any delimiters (']' or
                       '}') after the number! */
                    diff = dcmp( readNumber(str1, buf1->buf + buf1->size, &next1),
                                 readNumber(str2, buf2->buf + buf2->size, &next2) );
                } else {
                    diff = dcmp( strtod(str1, &next1), strtod(str2, &next2) );
                }
                if (diff)
                    return diff; /* Numbers don't match */
                str1 = next1;
                str2 = next2;
                break;
            }
            case kString: {
                int diff;
                if (mode == kCollateJSON_Unicode)
                    diff = compareStringsUnicode(&str1, &str2);
                else
                    diff = compareStringsASCII(&str1, &str2);
                if (diff)
                    return diff; /* Strings don't match */
                break;
            }
            case kArray:
            case kObject:
                ++str1;
                ++str2;
                ++depth;
                break;
            case kEndArray:
            case kEndObject:
                ++str1;
                ++str2;
                --depth;
                break;
            case kComma:
            case kColon:
                ++str1;
                ++str2;
                break;
            case kIllegal:
                return 0;
        }
    /* Keep going as long as we're inside an array or object */
    } while (depth > 0);
    return 0;
}

//.........这里部分代码省略.........
				sh_to_reg(op.rs1, mov, call_regs[0]);
				sh_to_reg(op.rs3, add, call_regs[0]);

				if (size != 8)
					sh_to_reg(op.rs2, mov, call_regs[1]);
				else
					sh_to_reg(op.rs2, mov, call_regs64[1]);

				if (size == 1)
					call((void*)WriteMem8);
				else if (size == 2)
					call((void*)WriteMem16);
				else if (size == 4)
					call((void*)WriteMem32);
				else if (size == 8)
					call((void*)WriteMem64);
				else {
					die("1..8 bytes");
				}
			}
			break;

			default:
				shil_chf[op.op](&op);
				break;
			}
		}

		mov(rax, (size_t)&next_pc);

		switch (block->BlockType) {

		case BET_StaticJump:
		case BET_StaticCall:
			//next_pc = block->BranchBlock;
			mov(dword[rax], block->BranchBlock);
			break;

		case BET_Cond_0:
		case BET_Cond_1:
			{
				//next_pc = next_pc_value;
				//if (*jdyn == 0)
				//next_pc = branch_pc_value;

				mov(dword[rax], block->NextBlock);

				if (block->has_jcond)
					mov(rdx, (size_t)&Sh4cntx.jdyn);
				else
					mov(rdx, (size_t)&sr.T);

				cmp(dword[rdx], block->BlockType & 1);
				Xbyak::Label branch_not_taken;

				jne(branch_not_taken, T_SHORT);
				mov(dword[rax], block->BranchBlock);
				L(branch_not_taken);
			}
			break;

		case BET_DynamicJump:
		case BET_DynamicCall:
		case BET_DynamicRet:
			//next_pc = *jdyn;
			mov(rdx, (size_t)&Sh4cntx.jdyn);
			mov(edx, dword[rdx]);
			mov(dword[rax], edx);
			break;

		case BET_DynamicIntr:
		case BET_StaticIntr:
			if (block->BlockType == BET_DynamicIntr) {
				//next_pc = *jdyn;
				mov(rdx, (size_t)&Sh4cntx.jdyn);
				mov(edx, dword[rdx]);
				mov(dword[rax], edx);
			}
			else {
				//next_pc = next_pc_value;
				mov(dword[rax], block->NextBlock);
			}

			call((void*)UpdateINTC);
			break;

		default:
			die("Invalid block end type");
		}


		add(rsp, 0x28);
		ret();

		ready();

		block->code = (DynarecCodeEntryPtr)getCode();

		emit_Skip(getSize());
	}

 void c_read(uint32_t v, unsigned char *buf, size_t len, off_t off)
 {
     memset(buf, 0xFF, len);
     read(buf, len, off);
     cmp(v, buf, len);
 }

static void
slurp(INPUT *F)
{
	LINE *lp, *lastlp, tmp;
	size_t len;
	int cnt;
	char *bp, *fieldp;

	/*
	 * Read all of the lines from an input file that have the same
	 * join field.
	 */
	F->setcnt = 0;
	for (lastlp = NULL;; ++F->setcnt) {
		/*
		 * If we're out of space to hold line structures, allocate
		 * more.  Initialize the structure so that we know that this
		 * is new space.
		 */
		if (F->setcnt == F->setalloc) {
			cnt = F->setalloc;
			F->setalloc += 50;
			if ((F->set = realloc(F->set,
			    F->setalloc * sizeof(LINE))) == NULL)
				err(1, NULL);
			memset(F->set + cnt, 0, 50 * sizeof(LINE));

			/* re-set lastlp in case it moved */
			if (lastlp != NULL)
				lastlp = &F->set[F->setcnt - 1];
		}

		/*
		 * Get any pushed back line, else get the next line.  Allocate
		 * space as necessary.  If taking the line from the stack swap
		 * the two structures so that we don't lose space allocated to
		 * either structure.  This could be avoided by doing another
		 * level of indirection, but it's probably okay as is.
		 */
		lp = &F->set[F->setcnt];
		if (F->setcnt)
			lastlp = &F->set[F->setcnt - 1];
		if (F->pushbool) {
			tmp = F->set[F->setcnt];
			F->set[F->setcnt] = F->set[F->pushback];
			F->set[F->pushback] = tmp;
			F->pushbool = 0;
			continue;
		}
		if ((bp = fgetln(F->fp, &len)) == NULL)
			return;
		if (lp->linealloc <= len + 1) {
			lp->linealloc += MAX(100, len + 1 - lp->linealloc);
			if ((lp->line =
			    realloc(lp->line, lp->linealloc)) == NULL)
				err(1, NULL);
		}
		memmove(lp->line, bp, len);

		/* Replace trailing newline, if it exists. */
		if (bp[len - 1] == '\n')
			lp->line[len - 1] = '\0';
		else
			lp->line[len] = '\0';
		bp = lp->line;

		/* Split the line into fields, allocate space as necessary. */
		lp->fieldcnt = 0;
		while ((fieldp = mbssep(&bp, tabchar)) != NULL) {
			if (spans && *fieldp == '\0')
				continue;
			if (lp->fieldcnt == lp->fieldalloc) {
				lp->fieldalloc += 50;
				if ((lp->fields = realloc(lp->fields,
				    lp->fieldalloc * sizeof(char *))) == NULL)
					err(1, NULL);
			}
			lp->fields[lp->fieldcnt++] = fieldp;
		}

		/* See if the join field value has changed. */
		if (lastlp != NULL && cmp(lp, F->joinf, lastlp, F->joinf)) {
			F->pushbool = 1;
			F->pushback = F->setcnt;
			break;
		}
	}
}

void testMassFunctions()
{
  dMass m;
  int i,j;
  dReal q[NUMP][3];		// particle positions
  dReal pm[NUMP];		// particle masses
  dMass m1,m2;
  dMatrix3 R;

  HEADER;

  printf ("\t");
  dMassSetZero (&m);
  TRAP_MESSAGE (dMassSetParameters (&m,10, 0,0,0, 1,2,3, 4,5,6),
		printf (" FAILED (1)\n"), printf (" passed (1)\n"));

  printf ("\t");
  dMassSetZero (&m);
  TRAP_MESSAGE (dMassSetParameters (&m,10, 0.1,0.2,0.15, 3,5,14, 3.1,3.2,4),
		printf ("passed (2)\n") , printf (" FAILED (2)\n"));
  if (m.mass==10 && m.c[0]==REAL(0.1) && m.c[1]==REAL(0.2) &&
      m.c[2]==REAL(0.15) && m._I(0,0)==3 && m._I(1,1)==5 && m._I(2,2)==14 &&
      m._I(0,1)==REAL(3.1) && m._I(0,2)==REAL(3.2) && m._I(1,2)==4 &&
      m._I(1,0)==REAL(3.1) && m._I(2,0)==REAL(3.2) && m._I(2,1)==4)
    printf ("\tpassed (3)\n"); else printf ("\tFAILED (3)\n");

  dMassSetZero (&m);
  dMassSetSphere (&m,1.4, 0.86);
  if (cmp(m.mass,3.73002719949386) && m.c[0]==0 && m.c[1]==0 && m.c[2]==0 &&
      cmp(m._I(0,0),1.10349124669826) &&
      cmp(m._I(1,1),1.10349124669826) &&
      cmp(m._I(2,2),1.10349124669826) &&
      m._I(0,1)==0 && m._I(0,2)==0 && m._I(1,2)==0 &&
      m._I(1,0)==0 && m._I(2,0)==0 && m._I(2,1)==0)
    printf ("\tpassed (4)\n"); else printf ("\tFAILED (4)\n");

  dMassSetZero (&m);
  dMassSetCapsule (&m,1.3,1,0.76,1.53);
  if (cmp(m.mass,5.99961928996029) && m.c[0]==0 && m.c[1]==0 && m.c[2]==0 &&
      cmp(m._I(0,0),1.59461986077384) &&
      cmp(m._I(1,1),4.21878433864904) &&
      cmp(m._I(2,2),4.21878433864904) &&
      m._I(0,1)==0 && m._I(0,2)==0 && m._I(1,2)==0 &&
      m._I(1,0)==0 && m._I(2,0)==0 && m._I(2,1)==0)
    printf ("\tpassed (5)\n"); else printf ("\tFAILED (5)\n");

  dMassSetZero (&m);
  dMassSetBox (&m,0.27,3,4,5);
  if (cmp(m.mass,16.2) && m.c[0]==0 && m.c[1]==0 && m.c[2]==0 &&
      cmp(m._I(0,0),55.35) && cmp(m._I(1,1),45.9) && cmp(m._I(2,2),33.75) &&
      m._I(0,1)==0 && m._I(0,2)==0 && m._I(1,2)==0 &&
      m._I(1,0)==0 && m._I(2,0)==0 && m._I(2,1)==0)
    printf ("\tpassed (6)\n"); else printf ("\tFAILED (6)\n");

  // test dMassAdjust?

  // make random particles and compute the mass, COM and inertia, then
  // translate and repeat.
  for (i=0; i<NUMP; i++) {
    pm[i] = dRandReal()+0.5;
    for (j=0; j<3; j++) {
      q[i][j] = 2.0*(dRandReal()-0.5);
    }
  }
  computeMassParams (&m1,q,pm);
  memcpy (&m2,&m1,sizeof(dMass));
  dMassTranslate (&m2,1,2,-3);
  for (i=0; i<NUMP; i++) {
    q[i][0] += 1;
    q[i][1] += 2;
    q[i][2] -= 3;
  }
  computeMassParams (&m1,q,pm);
  compareMassParams (&m1,&m2,"7");

  // rotate the masses
  _R(0,0) = -0.87919618797635;
  _R(0,1) = 0.15278881840384;
  _R(0,2) = -0.45129772879842;
  _R(1,0) = -0.47307856232664;
  _R(1,1) = -0.39258064912909;
  _R(1,2) = 0.78871864932708;
  _R(2,0) = -0.05666336483842;
  _R(2,1) = 0.90693771059546;
  _R(2,2) = 0.41743652473765;
  dMassRotate (&m2,R);
  for (i=0; i<NUMP; i++) {
    dReal a[3];
    dMultiply0 (a,&_R(0,0),&q[i][0],3,3,1);
    q[i][0] = a[0];
    q[i][1] = a[1];
    q[i][2] = a[2];
  }
  computeMassParams (&m1,q,pm);
  compareMassParams (&m1,&m2,"8");
}

int
avro_value_cmp_fast(avro_value_t *val1, avro_value_t *val2)
{
	avro_type_t  type1 = avro_value_get_type(val1);
	avro_type_t  type2 = avro_value_get_type(val2);
	if (type1 != type2) {
		return -1;
	}

	switch (type1) {
		case AVRO_BOOLEAN:
		{
			int  v1;
			int  v2;
			check_return(0, avro_value_get_boolean(val1, &v1));
			check_return(0, avro_value_get_boolean(val2, &v2));
			return cmp(!!v1, !!v2);
		}

		case AVRO_BYTES:
		{
			const void  *buf1;
			const void  *buf2;
			size_t  size1;
			size_t  size2;
			size_t  min_size;
			int  result;

			check_return(0, avro_value_get_bytes(val1, &buf1, &size1));
			check_return(0, avro_value_get_bytes(val2, &buf2, &size2));

			min_size = (size1 < size2)? size1: size2;
			result = memcmp(buf1, buf2, min_size);
			if (result != 0) {
				return result;
			} else {
				return cmp(size1, size2);
			}
		}

		case AVRO_DOUBLE:
		{
			double  v1;
			double  v2;
			check_return(0, avro_value_get_double(val1, &v1));
			check_return(0, avro_value_get_double(val2, &v2));
			return cmp(v1, v2);
		}

		case AVRO_FLOAT:
		{
			float  v1;
			float  v2;
			check_return(0, avro_value_get_float(val1, &v1));
			check_return(0, avro_value_get_float(val2, &v2));
			return cmp(v1, v2);
		}

		case AVRO_INT32:
		{
			int32_t  v1;
			int32_t  v2;
			check_return(0, avro_value_get_int(val1, &v1));
			check_return(0, avro_value_get_int(val2, &v2));
			return cmp(v1, v2);
		}

		case AVRO_INT64:
		{
			int64_t  v1;
			int64_t  v2;
			check_return(0, avro_value_get_long(val1, &v1));
			check_return(0, avro_value_get_long(val2, &v2));
			return cmp(v1, v2);
		}

		case AVRO_NULL:
		{
			check_return(0, avro_value_get_null(val1));
			check_return(0, avro_value_get_null(val2));
			return 0;
		}

		case AVRO_STRING:
		{
			const char  *buf1;
			const char  *buf2;
			size_t  size1;
			size_t  size2;
			size_t  min_size;
			int  result;
			check_return(0, avro_value_get_string(val1, &buf1, &size1));
			check_return(0, avro_value_get_string(val2, &buf2, &size2));

			min_size = (size1 < size2)? size1: size2;
			result = memcmp(buf1, buf2, min_size);
			if (result != 0) {
				return result;
			} else {
				return cmp(size1, size2);
//.........这里部分代码省略.........

 virtual bool eq(const Object *rhs)const override { return cmp(rhs) == 0; }

int main(void)
{

	number_passed = 0;
	number_failed = 0;

	int data_read;

	printf("\n\n");
	delay(1000);

	data_read = read(SIM_HOST_BASE_ADDR + HOST_SLAVE_CONTROL_BASE + HOST_SLAVE_VERSION_REG); // 225
	printf("Host Version number = 0x%0X\n", data_read);
	data_read = read(SIM_SLAVE_BASE_ADDR + HOST_SLAVE_CONTROL_BASE + HOST_SLAVE_VERSION_REG); // 481
	printf("Slave Version number = 0x%0X\n", data_read);

	printf("Testing host register read/write \n");
	write(SIM_HOST_BASE_ADDR + HCREG_BASE + TX_LINE_CONTROL_REG, 0x18); // 2
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + TX_LINE_CONTROL_REG, 0x18); // 2
	printf("Testing slave register read/write \n");
	write(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_CONTROL_REG, 0x70); // 336
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_CONTROL_REG , 0x70); // 336

	printf("Testing register reset \n");
	write(SIM_HOST_BASE_ADDR + HOST_SLAVE_CONTROL_BASE + HOST_SLAVE_CONTROL_REG, 0x2); // 224
	write(SIM_SLAVE_BASE_ADDR + HOST_SLAVE_CONTROL_BASE + HOST_SLAVE_CONTROL_REG, 0x2); // 480
	delay(1000);
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + TX_LINE_CONTROL_REG, 0x00); // 2
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_CONTROL_REG, 0x00); // 336
	delay(1000);

	printf("Configure host and slave mode.\n");
	write(SIM_HOST_BASE_ADDR + HOST_SLAVE_CONTROL_BASE + HOST_SLAVE_CONTROL_REG, 0x1);
	write(SIM_SLAVE_BASE_ADDR + HOST_SLAVE_CONTROL_BASE + HOST_SLAVE_CONTROL_REG, 0x0);

	printf("Connect full speed\n");
	write(SIM_HOST_BASE_ADDR + HCREG_BASE + TX_LINE_CONTROL_REG, 0x18);
	write(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_CONTROL_REG, 0x70);
	delay(20000);
	//expecting connection event interrupt
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + INTERRUPT_STATUS_REG, 0x04);
	//expecting full speed connect
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + RX_CONNECT_STATE_REG, 0x02);
	//expecting change in reset state event, and change in vbus state event
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x24);
	//expecting full speed connect and vbus present
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_LINE_STATUS_REG, 0x06);

	printf("Cancel interrupts\n");
	write(SIM_HOST_BASE_ADDR + HCREG_BASE + INTERRUPT_STATUS_REG, 0x04);
	write(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x24);
	//expecting all interrupts cancelled
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + INTERRUPT_STATUS_REG, 0x00);
	//expecting all interrupts cancelled
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x00);
	delay(1000);

	printf("Disconnect\n");
	write(SIM_HOST_BASE_ADDR + HCREG_BASE + TX_LINE_CONTROL_REG, 0x18);
	write(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_CONTROL_REG , 0x30);
	delay(10000);
	//expecting connection event interrupt
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + INTERRUPT_STATUS_REG, 0x04);
	//expecting disconnect state
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + RX_CONNECT_STATE_REG, 0x00);
	//expecting change in reset state event
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x04);
	//expecting vbus present, and disconnect state
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_LINE_STATUS_REG, 0x04);
	//cancel interrupts
	write(SIM_HOST_BASE_ADDR + HCREG_BASE + INTERRUPT_STATUS_REG, 0x04);
	write(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x04);

	printf("Connect full speed\n");
	write(SIM_HOST_BASE_ADDR + HCREG_BASE + TX_LINE_CONTROL_REG, 0x18);
	write(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_CONTROL_REG, 0x70);
	delay(20000);
	//expecting connection event interrupt
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + INTERRUPT_STATUS_REG, 0x04);
	//expecting full speed connect
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + RX_CONNECT_STATE_REG, 0x02);
	//expecting change in reset state event
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x04);
	//expecting full speed connect and vbus present
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_LINE_STATUS_REG, 0x06);
	//cancel interrupts
	write(SIM_HOST_BASE_ADDR + HCREG_BASE + INTERRUPT_STATUS_REG, 0x04);
	write(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x04);
	cmp(SIM_HOST_BASE_ADDR + HCREG_BASE + INTERRUPT_STATUS_REG, 0x00);
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x00);
	delay(1000);

	printf("Host forcing reset\n");
	write(SIM_HOST_BASE_ADDR + HCREG_BASE+TX_LINE_CONTROL_REG, 0x1c);
	delay(20000);
	//expecting change in reset state event
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_INTERRUPT_STATUS_REG, 0x04);
	//expecting vbus present, and disconnect state
	cmp(SIM_SLAVE_BASE_ADDR + SCREG_BASE + SC_LINE_STATUS_REG, 0x04);
	//cancel interrupt
//.........这里部分代码省略.........

void GetReady::readTFGene(GeneIM temp_gene_IM[],double **old_GRN,string TF_Gene_address)
{
    ifstream data(TF_Gene_address.c_str());
	char ch;
	int i,num=0;
	char *Name;
	char STRING1[GENEAM][10];
	data.get(ch);
	for(i=gene_amount;i<GENEAM;)
	{
		int a,b;
		while(ch=='#')
		{
			string noUse;
			getline(data,noUse);
			data.get(ch);
		}
		while(ch!='	')
		{
			STRING1[i][num]=ch;
			data.get(ch);
			num++;
		}
		STRING1[i][num]='\0';
		Name=STRING1[i];
		int j;
		for(j=0;j<i;j++)
		{
            lwr(Name);
            if(cmp(temp_gene_IM[j].gene_name,Name)==0)
			{
				a=j;
				j=i+1;
			}
		}
		if(j==i)
		{
			temp_gene_IM[i].name=Name;
			temp_gene_IM[i].putName();
			temp_gene_IM[i].gene_number=i;
			a=i;
			i++;
		}
		data.get(ch);
		num=0;
		while(ch!='	')
		{
			STRING1[i][num]=ch;
			data.get(ch);
			num++;
		}
		STRING1[i][num]='\0';
		Name=STRING1[i];
		for(j=0;j<i;j++)
		{
            lwr(Name);
            if(cmp(temp_gene_IM[j].gene_name,Name)==0)
			{
				b=j;
				j=i+1;
			}
		}
		if(j==i)
		{
			temp_gene_IM[i].name=Name;
			temp_gene_IM[i].putName();
			temp_gene_IM[i].gene_number=i;
			b=i;
			i++;
		}
		data.get(ch);
		if(ch=='-')
		{
			if(old_GRN[b][a]==1||old_GRN[b][a]==2)
			{
                if(old_GRN[b][a]!=2)
                    uncertain<<"?\t"<<temp_gene_IM[b].getGeneName()<<"->"<<temp_gene_IM[a].getGeneName()<<endl;
                old_GRN[b][a]=2;
				uncertain_row.push_back(b);
				uncertain_column.push_back(a);
				unknow++;
			}
			else
				old_GRN[b][a]=-1;
		}
		else if(ch=='+')
		{
			data.get(ch);
			if(ch=='-')
			{
				old_GRN[b][a]=2;
				uncertain_row.push_back(b);
				uncertain_column.push_back(a);
				uncertain<<"?\t"<<temp_gene_IM[b].getGeneName()<<"->"<<temp_gene_IM[a].getGeneName()<<endl;
				unknow++;
			}
			else
				old_GRN[b][a]=1;
		}
		else
//.........这里部分代码省略.........

void receive_matx32d(cv::Matx32d matx)
{
    double t[6] = {0.445, 0.473, 0.765, 0.523, 0.832, 0.345};
    cmp(matx, t);
}

bool Resultado::operator<(const Resultado& r) const {
	return (cmp(this->J, r.J) < 0);
}

double Resultado::atualizaJ(const Repositorio& repositorio) {
	double novoJ = calculaJ(repositorio);
	assert(cmp(novoJ,this->J) <= 0);
	return (this->J = novoJ);
}

//除法计算
void divid(const char a[],const char b[],char result[])
{
    bool isNegative = false;
    char *op1,*pa,*pb,*pr;
    int up,alen,blen,adotp,bdotp,i,k,dotp,t,t1,j,quo_size;
    /////////////判定符号///////////////
    //如果为异号
    if((a[0] == '-'||b[0] == '-')&&a[0] != b[0])
        result[0] = '-',isNegative = true;
    
    //去除负号
    if(a[0] == '-')a++;
    if(b[0] == '-')b++;
    ///////////////////////////////////
    
    alen = strlen(a)-1; //减去一位小数点
    blen = strlen(b)-1;
    
    ///////获取被除数小数点移位后的位置//////////
    adotp = strchr(a,'.')-a;
    bdotp = strchr(b,'.')-b;
    
    //计算商小数点位置
    dotp = adotp+blen-bdotp;
    if(isNegative)dotp++;
    
    //////////准备数据/////////////
    op1 = (char *)calloc(alen+blen+1,sizeof(char));
    pa = (char *)calloc(alen+blen+1,sizeof(char));
    pb = (char *)calloc(blen+1,sizeof(char));
    pr = (char *)calloc(alen+blen+1,sizeof(char));
    
    for(i = 0,t=0; i<=alen; i++)
    {
        if(a[i]!='.')
            pa[t++] = a[i];
    }
    for(;t<dotp-1;t++)
    {
        pa[t] = '0';
    }
    for(;t<blen;t++)
    {
        pa[t] = '0';
    }
    
    pa[t] = '\0';
    for(i = 0,t=0; i<=blen; i++)
    {
        if(b[i]!='.')
            pb[t++] = b[i];
    }
    pb[t] = '\0';
    clz(pa);
    clz(pb);
    ////////取得被除数的高位数op1,且op1大于被除数b//////////
    strncpy(op1,pa,strlen(pb));
    if(strcmp(op1,pb)<0)
    {
        strncpy(op1,pa,strlen(pb)+1);
    }
    
    /////计算//////
    j = k = strlen(op1);
    t1=0;
    quo_size = strlen(pa)+1-k; //获取商的长度
    
    while(t1<quo_size)
    {
        up = 0;
        t = cmp(op1,pb);
        while(t>=0)
        {
            dsub(op1,pb);
            t = cmp(op1,pb);
            up++;
        }
        pr[t1++] = up+'0';
        op1[strlen(op1)]=pa[j++];
        clz(op1);
    }
    quo_size+=50;//加50精度
    while(t1<quo_size&&(cmp(op1,(char *)"0")>0))
    {
        up = 0;
        op1[strlen(op1)]='0';
        t = cmp(op1,pb);
        while(t>=0)
        {
            dsub(op1,pb);
            t = cmp(op1,pb);
            up++;
        }
        pr[t1++] = up+'0';                    
    }
    //////////////////////////////
    
    if(isNegative)t=1;
    else t=0;
//.........这里部分代码省略.........

 int Group::cmp(const basic_group<Element>* other) const {
  int ct = cmpTypes(*this, *other);
  if (ct != 0) return ct;
  const Group* c = static_cast<const Group*>(other);
  return cmp(*c);
 }

//.........这里部分代码省略.........
			    strtol(optarg, &end, 10)) < 1)
				errx(1, "-j option field number less than 1");
			if (*end)
				errx(1, "illegal field number -- %s", optarg);
			--F1->joinf;
			--F2->joinf;
			break;
		case 'o':
			fieldarg(optarg);
			break;
		case 't':
			spans = 0;
			if (mbrtowc(&tabchar[0], optarg, MB_LEN_MAX, NULL) !=
			    strlen(optarg))
				errx(1, "illegal tab character specification");
			tabchar[1] = L'\0';
			break;
		case 'v':
			vflag = 1;
			joinout = 0;
			switch (strtol(optarg, &end, 10)) {
			case 1:
				F1->unpair = 1;
				break;
			case 2:
				F2->unpair = 1;
				break;
			default:
				errx(1, "-v option file number not 1 or 2");
				break;
			}
			if (*end)
				errx(1, "illegal file number -- %s", optarg);
			break;
		case '?':
		default:
			usage();
		}
	}
	argc -= optind;
	argv += optind;

	if (aflag && vflag)
		errx(1, "the -a and -v options are mutually exclusive");

	if (argc != 2)
		usage();

	/* Open the files; "-" means stdin. */
	if (!strcmp(*argv, "-"))
		F1->fp = stdin;
	else if ((F1->fp = fopen(*argv, "r")) == NULL)
		err(1, "%s", *argv);
	++argv;
	if (!strcmp(*argv, "-"))
		F2->fp = stdin;
	else if ((F2->fp = fopen(*argv, "r")) == NULL)
		err(1, "%s", *argv);
	if (F1->fp == stdin && F2->fp == stdin)
		errx(1, "only one input file may be stdin");

	slurp(F1);
	slurp(F2);
	while (F1->setcnt && F2->setcnt) {
		cval = cmp(F1->set, F1->joinf, F2->set, F2->joinf);
		if (cval == 0) {
			/* Oh joy, oh rapture, oh beauty divine! */
			if (joinout)
				joinlines(F1, F2);
			slurp(F1);
			slurp(F2);
		} else if (cval < 0) {
			/* File 1 takes the lead... */
			if (F1->unpair)
				joinlines(F1, NULL);
			slurp(F1);
		} else {
			/* File 2 takes the lead... */
			if (F2->unpair)
				joinlines(F2, NULL);
			slurp(F2);
		}
	}

	/*
	 * Now that one of the files is used up, optionally output any
	 * remaining lines from the other file.
	 */
	if (F1->unpair)
		while (F1->setcnt) {
			joinlines(F1, NULL);
			slurp(F1);
		}
	if (F2->unpair)
		while (F2->setcnt) {
			joinlines(F2, NULL);
			slurp(F2);
		}
	exit(0);
}

template <class Phenotype> inline void population<Phenotype>::sort() {
    compare_members cmp(a);
    std::sort(pvec.begin(), pvec.end(), cmp);
}

ATTRIBUTE_CLIB_SECTION
void
qsort(void *a, size_t n, size_t es, cmp_t *cmp)
{
	char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
	int d, r, swap_cnt;

loop:
	swap_cnt = 0;
	if (n < 7) {
		for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
			for (pl = pm; pl > (char *)a && cmp(pl - es, pl) > 0;
			     pl -= es)
				swap(pl, pl - es);
		return;
	}
	pm = (char *)a + (n / 2) * es;
	if (n > 7) {
		pl = a;
		pn = (char *)a + (n - 1) * es;
		if (n > 40) {
			d = (n / 8) * es;
			pl = med3(pl, pl + d, pl + 2 * d, cmp);
			pm = med3(pm - d, pm, pm + d, cmp);
			pn = med3(pn - 2 * d, pn - d, pn, cmp);
		}
		pm = med3(pl, pm, pn, cmp);
	}
	swap(a, pm);
	pa = pb = (char *)a + es;

	pc = pd = (char *)a + (n - 1) * es;
	for (;;) {
		while (pb <= pc && (r = cmp(pb, a)) <= 0) {
			if (r == 0) {
				swap_cnt = 1;
				swap(pa, pb);
				pa += es;
			}
			pb += es;
		}
		while (pb <= pc && (r = cmp(pc, a)) >= 0) {
			if (r == 0) {
				swap_cnt = 1;
				swap(pc, pd);
				pd -= es;
			}
			pc -= es;
		}
		if (pb > pc)
			break;
		swap(pb, pc);
		swap_cnt = 1;
		pb += es;
		pc -= es;
	}
	if (swap_cnt == 0) {  /* Switch to insertion sort */
		for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
			for (pl = pm; pl > (char *)a && cmp(pl - es, pl) > 0;
			     pl -= es)
				swap(pl, pl - es);
		return;
	}

	pn = (char *)a + n * es;
	r = min(pa - (char *)a, pb - pa);
	vecswap(a, pb - r, r);
	r = min(pd - pc, pn - pd - es);
	vecswap(pb, pn - r, r);
	if ((r = pb - pa) > es)
		qsort(a, r / es, es, cmp);
	if ((r = pd - pc) > es) {
		/* Iterate rather than recurse to save stack space */
		a = pn - r;
		n = r / es;
		goto loop;
	}
/*		qsort(pn - r, r / es, es, cmp);*/
}

void C1_MacroAssembler::allocate_array(
  Register obj,                        // result: pointer to array after successful allocation
  Register len,                        // array length
  Register t1,                         // temp register
  Register t2,                         // temp register
  Register t3,                         // temp register
  int      hdr_size,                   // object header size in words
  int      elt_size,                   // element size in bytes
  Register klass,                      // object klass
  Label&   slow_case                   // continuation point if fast allocation fails
) {
  assert_different_registers(obj, len, t1, t2, t3, klass);
  assert(klass == G5, "must be G5");
  assert(t1 == G1, "must be G1");

  // determine alignment mask
  assert(!(BytesPerWord & 1), "must be a multiple of 2 for masking code to work");

  // check for negative or excessive length
  // note: the maximum length allowed is chosen so that arrays of any
  //       element size with this length are always smaller or equal
  //       to the largest integer (i.e., array size computation will
  //       not overflow)
  set(max_array_allocation_length, t1);
  cmp(len, t1);
  br(Assembler::greaterUnsigned, false, Assembler::pn, slow_case);

  // compute array size
  // note: if 0 <= len <= max_length, len*elt_size + header + alignment is
  //       smaller or equal to the largest integer; also, since top is always
  //       aligned, we can do the alignment here instead of at the end address
  //       computation
  const Register arr_size = t1;
  switch (elt_size) {
    case  1: delayed()->mov(len,    arr_size); break;
    case  2: delayed()->sll(len, 1, arr_size); break;
    case  4: delayed()->sll(len, 2, arr_size); break;
    case  8: delayed()->sll(len, 3, arr_size); break;
    default: ShouldNotReachHere();
  }
  add(arr_size, hdr_size * wordSize + MinObjAlignmentInBytesMask, arr_size); // add space for header & alignment
  and3(arr_size, ~MinObjAlignmentInBytesMask, arr_size);                     // align array size

  // allocate space & initialize header
  if (UseTLAB) {
    tlab_allocate(obj, arr_size, 0, t2, slow_case);
  } else {
    eden_allocate(obj, arr_size, 0, t2, t3, slow_case);
  }
  initialize_header(obj, klass, len, t2, t3);

  // initialize body
  const Register base  = t2;
  const Register index = t3;
  add(obj, hdr_size * wordSize, base);               // compute address of first element
  sub(arr_size, hdr_size * wordSize, index);         // compute index = number of words to clear
  initialize_body(base, index);

  if (CURRENT_ENV->dtrace_alloc_probes()) {
    assert(obj == O0, "must be");
    call(CAST_FROM_FN_PTR(address, Runtime1::entry_for(Runtime1::dtrace_object_alloc_id)),
         relocInfo::runtime_call_type);
    delayed()->nop();
  }

  verify_oop(obj);
}