Example #1
0
static void
dinfo(int dn, int r, int c)
{
	double atime;
#define ADV if (disk_horiz) r++; else c += DISKCOLWIDTH

	mvprintw(r, c, "%*.*s", DISKCOLWIDTH, DISKCOLWIDTH, dr_name[dn]);
	ADV;

	putint((int)(cur.seek[dn]/etime+0.5), r, c, DISKCOLWIDTH);
	ADV;
	putint((int)((cur.rxfer[dn]+cur.wxfer[dn])/etime+0.5),
	    r, c, DISKCOLWIDTH);
	ADV;
	puthumanint((cur.rbytes[dn] + cur.wbytes[dn]) / etime + 0.5,
		    r, c, DISKCOLWIDTH);
	ADV;

	/* time busy in disk activity */
	atime = cur.time[dn].tv_sec + cur.time[dn].tv_usec / 1000000.0;
	atime = atime * 100.0 / etime;
	if (atime >= 100)
		putint(100, r, c, DISKCOLWIDTH);
	else
		putfloat(atime, r, c, DISKCOLWIDTH, 1, 1);
}
Example #2
0
static int
assemble_athena_ticket(char *ticket, int *ticketLen, char *name, char *inst,
		       char *realm, afs_int32 host,
		       struct ktc_encryptionKey *sessionKey, afs_uint32 start,
		       afs_uint32 end, char *sname, char *sinst)
{
    char *ticketBeg = ticket;
    int slen;
    unsigned char life;

    *ticket++ = 0;		/* flags, always send net-byte-order */
    putstr(name, 1);
    putstr(inst, 0);
    putstr(realm, 0);
    putint(host);

    memcpy(ticket, sessionKey, sizeof(struct ktc_encryptionKey));
    ticket += sizeof(struct ktc_encryptionKey);

    life = time_to_life(start, end);
    if (life == 0)
	return -1;
    *ticket++ = life;

    putint(start);
    putstr(sname, 1);
    putstr(sinst, 0);

    *ticketLen = ticket - ticketBeg;
    return 0;
}
Example #3
0
void display(void){	
	clear(2,4,2);
	clear(3,4,2);
	clear(4,4,2);
	clear(2,11,3);
	clear(3,11,2);
	clear(4,11,4);
	cursorxy(2,4);//set cursor
	//putint(light,3);//print data from adc
	putint(light,2);
	//cursorxy(2,7);
	putstr((unsigned char*)"%");
	cursorxy(2,11);
	putint(humidity,3);
	putstr((unsigned char*)"%");
	cursorxy(3,4);//set cursor
	putint(temp1,2);//print data from adc
	putstr((unsigned char*)"^");
	cursorxy(3,11);
	putint(pressure,2);
	putstr((unsigned char*)"kP");
	cursorxy(4,4);//set cursor
	putint(temp2,2);//print data from adc
	putstr((unsigned char*)"^");
	cursorxy(4,11);
	if(soil<30)
		putstr((unsigned char*)"Wet");
	else if(soil>70)
		putstr((unsigned char*)"Dry");
	else
		putstr((unsigned char*)"Mid");
	
}
Example #4
0
static afs_int32
create_reply(struct packet *ans, char *name, char *inst, Date startTime,
	     Date endTime, afs_int32 kvno, char *cipher, int cipherLen)
{
    char *answer = ans->data;
    int slen;

    ans->len = 2 + strlen(name) + strlen(inst) + 3 /*nulls */  +
	sizeof(afs_int32) + 1 /*ntkts */  + sizeof(afs_int32) + 1 /*kvno */  +
	sizeof(short) + cipherLen;
    if (ans->len > sizeof(ans->data))
	return KAANSWERTOOLONG;
    if (kvno > 255)
	return KAANSWERTOOLONG;

    *answer++ = (unsigned char)KRB_PROT_VERSION;
    *answer++ = (unsigned char)AUTH_MSG_KDC_REPLY;
    /* always send claiming network byte order */
    putstr(name);
    putstr(inst);
    putstr("");
    putint(startTime);
    *answer++ = 1;		/* undocumented number of tickets! */
    putint(endTime);
    *answer++ = (unsigned char)kvno;
    {
	short w = (short)cipherLen;
	w = htons(w);
	memcpy(answer, &w, sizeof(short));
	answer += sizeof(short);
    }
    memcpy(answer, cipher, cipherLen);
    return 0;
}
Example #5
0
void send_welcome(int n) {
	ENetPacket * packet = enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
	uchar *start = packet->data;
	uchar *p = start + 2;
	putint(p, SV_INITS2C);
	putint(p, n);
	putint(p, PROTOCOL_VERSION);
	putint(p, smapname[0]);
	sendIString(serverpassword, p);
	putint(p, clients.size() > maxclients);
	if (smapname[0]) {
		putint(p, SV_MAPCHANGE);
		sendIString(smapname, p);
		putint(p, mode);
		putint(p, SV_ITEMLIST);
		for (int i = 0; i < sents.size(); i++) {
			if (sents[i].spawned)
				putint(p, i);
		}
		putint(p, -1);
	};
	*(ushort *) start = ENET_HOST_TO_NET_16(p - start);
	enet_packet_resize(packet, p - start);
	send(n, packet);
}
Example #6
0
void sendmap(char *mapname)
{
    if(*mapname) save_world(mapname);
    changemap(mapname);
    mapname = getclientmap();
    int mapsize;
    uchar *mapdata = readmap(mapname, &mapsize); 
    if(!mapdata) return;
    ENetPacket *packet = enet_packet_create(NULL, MAXTRANS + mapsize, ENET_PACKET_FLAG_RELIABLE);
    uchar *start = packet->data;
    uchar *p = start+2;
    putint(p, SV_SENDMAP);
    sendstring(mapname, p);
    putint(p, mapsize);
    if(65535 - (p - start) < mapsize)
    {
        conoutf("map %s is too large to send", mapname);
        free(mapdata);
        enet_packet_destroy(packet);
        return;
    };
    memcpy(p, mapdata, mapsize);
    p += mapsize;
    free(mapdata); 
    *(ushort *)start = ENET_HOST_TO_NET_16(p-start);
    enet_packet_resize(packet, p-start);
    sendpackettoserv(packet);
    conoutf("sending map %s to server...", mapname);
    sprintf_sd(msg)("[map %s uploaded to server, \"getmap\" to receive it]", mapname);
    toserver(msg);
}
Example #7
0
File: sim08.c Project: Chilinot/uC
void foo(int v1, int v2, int v3, int v4, int v5) {
  putint( v1);
  putint( v2);
  putint( v3);
  putint( v4);
  putint( v5);
}
Example #8
0
void serverms(int mode, int numplayers, int minremain, char *smapname, int seconds, bool isfull) {
  checkmasterreply();
  updatemasterserver(seconds);

  // reply all server info requests
  ENetBuffer buf;
  ENetAddress addr;
  u8 pong[MAXTRANS], *p;
  int len;
  enet_uint32 events = ENET_SOCKET_WAIT_RECEIVE;
  buf.data = pong;
  while (enet_socket_wait(pongsock, &events, 0) >= 0 && events) {
    buf.dataLength = sizeof(pong);
    len = enet_socket_receive(pongsock, &addr, &buf, 1);
    if (len < 0) return;
    p = &pong[len];
    putint(p, PROTOCOL_VERSION);
    putint(p, mode);
    putint(p, numplayers);
    putint(p, minremain);
    string mname;
    strcpy_s(mname, isfull ? "[FULL] " : "");
    strcat_s(mname, smapname);
    sendstring(mname, p);
    sendstring(serverdesc, p);
    buf.dataLength = p - pong;
    enet_socket_send(pongsock, &addr, &buf, 1);
  }
}
Example #9
0
static PyObject *sendPacket(PyObject *self, PyObject *args)
{
    
    int goodcn = -1;
    
    packetbuf p(MAXTRANS,ENET_PACKET_FLAG_RELIABLE);
    putint(p, N_CLIENT);
	std::cout<<"N_CLIENT ";
    
    loopv(server::clients) {
        int cn = server::clients[i]->clientnum;
        if(goodcn < 0) goodcn = cn; // find a good cn
    }
    
    putint(p, goodcn);
    std::cout<<goodcn<<" ";
    
    putuint(p, (((unsigned int)PyTuple_Size(args)))*2);
    std::cout<<(((unsigned int)PyTuple_Size(args))*2)<<" [ ";
    
    for(Py_ssize_t i=0;i<PyTuple_Size(args);i++)
    {
        int data=PyInt_AsLong(PyTuple_GetItem(args,i));
        std::cout<<data<<" ";
        putint(p, data);
    }
            
    sendpacket(-1, 1, p.finalize(), -1);
    std::cout<<"- sent\n";
    
    Py_INCREF(Py_None);
    return Py_None;
}
Example #10
0
File: sim03.c Project: Chilinot/uC
int main(void) {
  int b[10];
  a[7] = 123;
  b[5] = 456;
  putint(a[7]);
  putint(b[5]);
  return 0;
}
Example #11
0
File: sim02.c Project: Chilinot/uC
int main(void) {
  int bar;
  foo = 76;
  bar = 54321;
  putint(foo);
  putint(bar);
  return 0;
}
Example #12
0
static int
err_packet(int ksoc, struct packet *pkt, afs_int32 code, char *reason)
{
    struct packet ans;
    char *answer = ans.data;
    int slen;
    char buf[256];

    if (reason == 0)
	reason = "";
    snprintf(buf, 255, "code = %d: %s", code, reason);

    if (krb_udp_debug) {
	printf("Sending error packet to '%s'.'%s'@'%s' containing %s\n",
	       pkt->name, pkt->inst, pkt->realm, buf);
    }

    ans.len =
	2 + strlen(pkt->name) + strlen(pkt->inst) + strlen(pkt->realm) +
	3 /* nulls */  + (2 * sizeof(afs_int32)) + strlen(buf) + 1;
    if (ans.len > sizeof(ans.data)) {
	printf("Answer packet too long\n");
	return -1;
    }

    *answer++ = (unsigned char)KRB_PROT_VERSION;
    *answer++ = (unsigned char)AUTH_MSG_ERR_REPLY;
    /* always send claiming network byte order */
    putstr(pkt->name);
    putstr(pkt->inst);
    putstr(pkt->realm);
    putint(pkt->time);
    if ((code < 0) || (code > KERB_ERR_MAXIMUM)) {
	/* It could be because of kauth errors so we should return something instead of success!! */
	code = KDC_GEN_ERR;
    }
    putint(code);
    putstr(buf);

    code =
	sendto(ksoc, ans.data, ans.len, 0, (struct sockaddr *)&pkt->from,
	       sizeof(pkt->from));
    if (code != ans.len) {
	if (code >= 0)
	    printf
		("call to sendto returned %d, sending error packet %d bytes long\n",
		 code, ans.len);
	else
	    perror("err_packet: sendto");
    }
    return 0;
}
Example #13
0
void
show_vmstat_top(vmtotal_t *Total, uvmexp_sysctl_t *uvm, uvmexp_sysctl_t *uvm1)
{
	float f1, f2;
	int psiz;
	int i, l, c;
	struct {
		struct uvmexp_sysctl *uvmexp;
	} us, us1;

	us.uvmexp = uvm;
	us1.uvmexp = uvm1;

	putint(ucount(), STATROW, STATCOL, 3);
	putfloat(avenrun[0], STATROW, STATCOL + 17, 6, 2, 0);
	putfloat(avenrun[1], STATROW, STATCOL + 23, 6, 2, 0);
	putfloat(avenrun[2], STATROW, STATCOL + 29, 6, 2, 0);
	mvaddstr(STATROW, STATCOL + 53, buf);

	putint(Total->t_rq - 1, PROCSROW + 1, PROCSCOL + 3, 3);
	putint(Total->t_dw, PROCSROW + 1, PROCSCOL + 6, 3);
	putint(Total->t_sl, PROCSROW + 1, PROCSCOL + 9, 3);

	PUTRATE(us, us1, uvmexp->swtch, GENSTATROW + 1, GENSTATCOL - 1, 7);
	PUTRATE(us, us1, uvmexp->traps, GENSTATROW + 1, GENSTATCOL + 7, 6);
	PUTRATE(us, us1, uvmexp->syscalls, GENSTATROW + 1, GENSTATCOL + 14, 6);
	PUTRATE(us, us1, uvmexp->intrs, GENSTATROW + 1, GENSTATCOL + 21, 5);
	PUTRATE(us, us1, uvmexp->softs, GENSTATROW + 1, GENSTATCOL + 27, 6);
	PUTRATE(us, us1, uvmexp->faults, GENSTATROW + 1, GENSTATCOL + 34, 6);

	/* Last CPU state not calculated yet. */
	for (f2 = 0.0, psiz = 0, c = 0; c < CPUSTATES; c++) {
		i = cpuorder[c];
		f1 = cputime(i);
		f2 += f1;
		l = (int) ((f2 + 1.0) / 2.0) - psiz;
		if (c == 0)
			putfloat(f1, GRAPHROW, GRAPHCOL + 1, 5, 1, 0);
		else
			putfloat(f1, GRAPHROW, GRAPHCOL + 10 * c + 1, 5, 1, 0);
		mvhline(GRAPHROW + 2, psiz, cpuchar[c], l);
		psiz += l;
	}

	PUTRATE(us, us1, uvmexp->pageins, PAGEROW + 2, PAGECOL + 5, 5);
	PUTRATE(us, us1, uvmexp->pdpageouts, PAGEROW + 2, PAGECOL + 10, 5);
	PUTRATE(us, us1, uvmexp->pgswapin, PAGEROW + 3, PAGECOL + 5, 5);
	PUTRATE(us, us1, uvmexp->pgswapout, PAGEROW + 3, PAGECOL + 10, 5);
}
Example #14
0
int main (void) {
  int i;
  char space[2];
  char cr[2];
  space[0] = ' ';  space[1] = 0;
  cr[0]    = '\n'; cr[1]    = 0;
  i = 0;
  while (i<=12) {
    putint(i);
    putstring(space);
    putint(fib(i));
    putstring(cr);
    i = i + 1;
  }
}
Example #15
0
int main()
{
    unsigned char c;
    uart0_init();  
	cur_timer_func = idle_func;
	init_timer_queue(&global_timer_queue);
	enqueue_timer(&global_timer_queue,1000,uart_message1);
	enqueue_timer(&global_timer_queue,300,uart_message2);
	enqueue_timer(&global_timer_queue,400,uart_message3);
  
	putc('T');
	putc('e');
	putc('s');
	putc('t');
	putc(':');
	putc('\n');
	putc('\r');
	putstr("str_test");
	putint(987649);
	
    while(1)
    {
        
        c = getc();
     		putc(c);
    }

    return 0;
}
Example #16
0
int main(void) {
  char nameq[];
  char ageq[];
  char youare[];
  char cr[];

  char name[80];
  int age;

  nameq = "Your name? ";
  ageq = "Your age ";
  youare = "You are: ";
  cr = "\n";

  putstring(nameq);
  getstring(name);

  putstring(ageq);
  age = getint();

  putstring(youare);
  putstring(name);
  putstring(cr);

  putstring(youare);
  putint(age);
  putstring(cr);


}
Example #17
0
void send2(bool rel, int cn, int a, int b) {
	ENetPacket *packet = enet_packet_create(NULL, 32,
			rel ? ENET_PACKET_FLAG_RELIABLE : 0);
	uchar *start = packet->data;
	uchar *p = start + 2;
	putint(p, a);
	putint(p, b);
	*(ushort *) start = ENET_HOST_TO_NET_16(p - start);
	enet_packet_resize(packet, p - start);
	if (cn < 0)
		process(packet, -1);
	else
		send(cn, packet);
	if (packet->referenceCount == 0)
		enet_packet_destroy(packet);
}
Example #18
0
Arraylist allGraphs(int rank) {
  Arraylist result = newArraylist(rank);
  Intstack cand = newIntstack(0, NULL), 
    fg = fullgraph(rank);
  unsigned long int x, y, ulim = 1 << fg->size;
  int i;
  setRank(rank);
  for (x = 0L; x < ulim; x++) {
    cand->size = 0;
    y = x;
    i = 0;
    while (y > 0) {
      if (y % 2 == 1) putint(fg->it[i], cand);
      y /= 2;
      i++;
    }
    if (portHistDescending(cand)) {
      putItem((void*) newIntstack(0, cand), result);
    } 
  }
  freestack(cand);
  freestack(fg);
  sortAndWeedForGraphs(rank, result);
  return result;
}
Example #19
0
int main(void)
{
	int t, n;
	usi a[MAX], maxcount, minindex, i, max;
	
	t = getint();
	while(t--)
	{	
		maxcount = max = minindex = 0;
		memset(a, 0, sizeof(usi) * MAX);
		
		n = getint();
		while(n--)
		{
			if(++a[i = (usi) (getint() - 1)] > max)
			{
				if((max = a[i]) == maxcount && i < minindex)
				{
					minindex = i;
				}
				else if(max > maxcount)
				{
					maxcount = max;
					minindex = i;
				}
				
			}
		}
		
		
		putint((int) (minindex + 1));
		putchar(' ');
		putint((int) maxcount);
		
		putchar('\n');
		
		for(i = 0; i < MAX; i++)
			if(a[i])
				printf("###\t\t%d : %d\n", i + 1, a[i]);
		putchar('\n');
		
	}
	
	return 0;
}
bool CslGameAssaultCube::PingDefault(ucharbuf& buf, CslServerInfo& info) const
{
    putint(buf, m_fourcc);

    if (info.Protocol==-1 || info.Protocol>=1128) // >=1.0.x
    {
        if (info.InfoText.IsEmpty())
        {
            putint(buf, AC_EXTPING_SERVERINFO);
            putint(buf, 'e'); putint(buf, 'n');
            return true;
        }
    }

    putint(buf, AC_EXTPING_NOP);

    return true;
}
Example #21
0
Intstack fullgraph(int rank) {
  Intstack result = newIntstack(rank * (rank-1) / 2, NULL);
  int p, q = 2, qlim = 1 << rank;
  for (q = 2; q < qlim; q <<= 1) 
    for (p = 1; p < q; p <<= 1) 
      putint(p+q, result);
  assert(result->size == rank * (rank-1) / 2);
  return result;
}
Example #22
0
File: fac-b.c Project: Chilinot/uC
int main(void) {
  int i;
  char space[2];
  char cr[2];
  space[0] = ' ';  space[1] = '\0';
  cr[0]    = '\n'; cr[1]    = (char)0;

  i = 0;

  while (i<=10) {
    putint(i);
    putstring(space);
    putint(fac(i));
    putstring(cr);
    i = i + 1;
  }
  return 0;
}
Example #23
0
static void
oputint(			/* write a siz-byte integer to stdout */
	register long  i,
	register int  siz
)
{
	putint(i, siz, stdout);
	if (ferror(stdout))
		error(SYSTEM, "write error in putint");
}
Example #24
0
int main(void){
	//printf("hello");
	//printf("\nhello again\n");
	int ret;
	char *exit = "Exiting program\n";
	char *help0 = "List of utilities\n";
	char *help1 = "help\tDisplays this help menu\n";
	char *help2 = "exit\tTerminates execution of the shell\n";
	char *help3 = "echo\tSimple utility that writes to stdout\n";
	char input[INPUT_BUFFER];
	while(!(strcmp(input,"exit\n")==1)){
		putchar('>');	
		fgets(INPUT_BUFFER, input);
		if(strcmp(input,"help\n")==1){
			putchar('\n');
                        printf("%s", help0);
			printf("%s", help1);			
			printf("%s",help2);			
			printf("%s", help3);
			ret = 0;
	 	}
		else if(strncmp(input, "echo",4)==1){
			if(input[5] == 36 && input[6]==63){
				//help(0);
				putint(ret);
				putchar('\n');
			}
			else{
				int x = strlen(input);
				int z = 5;
				while(z<x){
					putchar(input[z]);
					z++;
				}
			
			}
		}
		else if(strcmp(input,"exit\n")==1);
		else{
			if(strlen(input)>256){
				printf("Path is too long\n");
				ret = -1;
			}
			else{
				char buff[INPUT_BUFFER];
				strncpy(buff, input, strlen(input)-2);
				ret = exec(buff);
				if(ret == -1){
					printf("%s:command not found\n", buff);
				}
			}
		}
	}
	printf("%s", exit);
}	
Example #25
0
static afs_int32
create_cipher(char *cipher, int *cipherLen,
	      struct ktc_encryptionKey *sessionKey, char *sname,
	      char *sinst, Date start, Date end, afs_int32 kvno,
	      char *ticket, int ticketLen, struct ktc_encryptionKey *key)
{
    char *answer;
    int slen;
    unsigned char life = time_to_life(start, end);
    int len;
    DES_key_schedule schedule;
    afs_int32 code;

    answer = cipher;
    len =
	sizeof(*sessionKey) + strlen(sname) + strlen(sinst) + strlen(lrealm) +
	3 /*nulls */  + 3 + ticketLen + sizeof(Date);
    if (len > *cipherLen)
	return KAANSWERTOOLONG;
    if (ticketLen > 255)
	return KAANSWERTOOLONG;
    if (kvno > 255)
	return KAANSWERTOOLONG;

    memcpy(answer, sessionKey, sizeof(*sessionKey));
    answer += sizeof(*sessionKey);
    putstr(sname);
    putstr(sinst);
    putstr(lrealm);
    *answer++ = life;
    *answer++ = (unsigned char)kvno;
    *answer++ = (unsigned char)ticketLen;
    memcpy(answer, ticket, ticketLen);
    answer += ticketLen;
    putint(start);

    if (krb_udp_debug) {
	printf("Printing ticket (%d) and date: ", ticketLen);
	ka_PrintBytes(ticket, ticketLen);
	ka_PrintBytes(answer - 4, 4);
	printf("\n");
    }

    if ((code = DES_key_sched(ktc_to_cblock(key), &schedule)))
	printf("In KAAuthenticate: key_sched returned %d\n", code);
    DES_pcbc_encrypt(cipher, cipher, len, &schedule, ktc_to_cblockptr(key), ENCRYPT);
    *cipherLen = round_up_to_ebs(len);

    if (krb_udp_debug) {
	printf("Printing cipher (%d): ", *cipherLen);
	ka_PrintBytes(cipher, *cipherLen);
	printf("\n");
    }
    return 0;
}
Example #26
0
void getmap()
{
    ENetPacket *packet = enet_packet_create(NULL, MAXTRANS, ENET_PACKET_FLAG_RELIABLE);
    uchar *start = packet->data;
    uchar *p = start+2;
    putint(p, SV_RECVMAP);
    *(ushort *)start = ENET_HOST_TO_NET_16(p-start);
    enet_packet_resize(packet, p-start);
    sendpackettoserv(packet);
    conoutf("requesting map from server...");
}
Example #27
0
void sendservmsg(const char *msg) {
  ENetPacket *packet = enet_packet_create(NULL, MAXDEFSTR+10, ENET_PACKET_FLAG_RELIABLE);
  u8 *start = packet->data;
  u8 *p = start+2;
  putint(p, SV_SERVMSG);
  sendstring(msg, p);
  *(u16 *)start = ENET_HOST_TO_NET_16(int(p-start));
  enet_packet_resize(packet, p-start);
  multicast(packet, -1);
  if (packet->referenceCount==0) enet_packet_destroy(packet);
}
Example #28
0
inline void putint(int N)
{
	if(N < 0)
	{
		putchar('-');
		N *= -1;	// check for potential overflows
	}
	if(N >= 10)
		putint(N / 10);
	putchar((N % 10) + '0');
}
Example #29
0
static void
dinfo(int dn, int c)
{
	double words, atime;

	c += DISKCOL;

	/* time busy in disk activity */
	atime = (double)cur.dk_time[dn].tv_sec +
	    ((double)cur.dk_time[dn].tv_usec / (double)1000000);

	/* # of K transferred */
	words = (cur.dk_rbytes[dn] + cur.dk_wbytes[dn]) / 1024.0;

	putint((int)((float)cur.dk_seek[dn]/etime+0.5), DISKROW + 1, c, 5);
	putint((int)((float)(cur.dk_rxfer[dn] + cur.dk_wxfer[dn])/etime+0.5),
	    DISKROW + 2, c, 5);
	putintmk((int)(words/etime + 0.5), DISKROW + 3, c, 5);
	putfloat(atime/etime, DISKROW + 4, c, 5, 1, 1);
}
Example #30
0
void
putflt(				/* put out floating point number */
    double	f,
    FILE  *fp
)
{
    long  m;
    int  e;

    m = frexp(f, &e) * 0x7fffffff;
    if (e > 127) {			/* overflow */
        m = m > 0 ? (long)0x7fffffff : -(long)0x7fffffff;
        e = 127;
    } else if (e < -128) {		/* underflow */
        m = 0;
        e = 0;
    }
    putint(m, 4, fp);
    putint((long)e, 1, fp);
}