int main(int argc, char **argv)
{
    initialize();
#ifdef __AFL_INIT
    // Enable AFL deferred forkserver mode. Requires compilation using
    // afl-clang-fast++. See fuzzing.md for details.
    __AFL_INIT();
#endif

#ifdef __AFL_LOOP
    // Enable AFL persistent mode. Requires compilation using afl-clang-fast++.
    // See fuzzing.md for details.
    int ret = 0;
    while (__AFL_LOOP(1000)) {
        std::vector<uint8_t> buffer;
        if (!read_stdin(buffer)) {
            continue;
        }
        ret = test_one_input(buffer);
    }
    return ret;
#else
    std::vector<uint8_t> buffer;
    if (!read_stdin(buffer)) {
        return 0;
    }
    return test_one_input(buffer);
#endif
}

int FAR _export
gsdll_callback(int message, char FAR *str, unsigned long count)
{
char buf[256];
    switch (message) {
	case GSDLL_POLL:
	    // Don't check message queue because we don't
	    // create any windows.
	    // May want to return error code if abort wanted
	    break;
	case GSDLL_STDIN:
	    return read_stdin(str, count);
	case GSDLL_STDOUT:
	    fwrite(str, 1, count, stdout);
	    fflush(stdout);
	    return count;
	case GSDLL_DEVICE:
	    if (count) {
		sprintf(buf, "mswindll device not supported in this version of Ghostscript\n");
		fputs(buf, stdout);
	    }
	    break;
	case GSDLL_SYNC:
	    break;
	case GSDLL_PAGE:
	    break;
	case GSDLL_SIZE:
	    break;
	default:
	    sprintf(buf,"Callback: Unknown message=%d\n",message);
	    fputs(buf, stdout);
	    break;
    }
    return 0;
}

static void stdin_cmd_poll(rarch_cmd_t *handle)
{
   if (!handle->stdin_enable)
      return;

   size_t ret = read_stdin(handle->stdin_buf + handle->stdin_buf_ptr, STDIN_BUF_SIZE - handle->stdin_buf_ptr - 1);
   if (ret == 0)
      return;

   handle->stdin_buf_ptr += ret;
   handle->stdin_buf[handle->stdin_buf_ptr] = '\0';

   char *last_newline = strrchr(handle->stdin_buf, '\n');
   if (!last_newline)
   {
      // We're receiving bogus data in pipe (no terminating newline),
      // flush out the buffer.
      if (handle->stdin_buf_ptr + 1 >= STDIN_BUF_SIZE)
      {
         handle->stdin_buf_ptr = 0;
         handle->stdin_buf[0] = '\0';
      }

      return;
   }

   *last_newline++ = '\0';
   ptrdiff_t msg_len = last_newline - handle->stdin_buf;

   parse_msg(handle, handle->stdin_buf);

   memmove(handle->stdin_buf, last_newline, handle->stdin_buf_ptr - msg_len);
   handle->stdin_buf_ptr -= msg_len;
}

static int	talker(int socketDescriptor, t_entry **entry)
{
  char		msg[MAX_MSG];
  int		i;

  get_connection(socketDescriptor);
  while (strcmp(msg, "quit") != 0)
    {
      bzero(msg, sizeof(msg));
      if ((read_stdin(msg)) == EXIT_FAILURE)
	return (EXIT_FAILURE);
      for (i = 0; entry[i]->cmd &&
	     strncmp(entry[i]->cmd, msg, strlen(entry[i]->cmd)) != 0; ++i);
      if (entry[i]->cmd != NULL)
	{
	  if ((entry[i]->fptr(msg, socketDescriptor)) == EXIT_FAILURE)
	    return (EXIT_FAILURE);
	}
      else
	{
	  if ((dprintf(socketDescriptor, "%s", msg)) == -1)
	    return (my_perror("dprintf"));
	}
      get_srv_ret(socketDescriptor);
    }
  return (EXIT_SUCCESS);
}

int				main(int ac, char **av)
{
	t_env	env;

	if (!(isatty(0)))
		error_quit("Invalid stdin, please run from terminal");
	g_env = &env;
	env.old_width = 0;
	env.old_height = 0;
	env.list_size = ac - 1;
	env.items = NULL;
	get_tty_fd(&env);
	build_list(&env, ac, av);
	env.curr = env.items;
	init_signals();
	tgetent(0, getenv("TERM"));
	if (!(env.caps = malloc(sizeof(*env.caps))))
		error_quit("Failed to malloc env caps");
	init_caps(env.caps);
	key_codes_init(&env);
	terminal_catch();
	env.fd = 2;
	while (1)
	{
		draw_list(&env);
		read_stdin(&env);
	}
}

int
main (int argc, char **argv) {
  uint32_t **freq = NULL;
  uint32_t *cur = NULL;
  char *buf = NULL;
  char *format = NULL;
  char *opt = 0;
  int cfirst = 1;

  if (1 == argc && 1 == isatty(0)) { return usage(), 1; }
  else if (ferror(stdin)) { return 1; }

  if (argc > 1) {
    while (*argv++) {
      opt = argv[0];
      switch (opt[0]) {
        case '-':
          switch (opt[1]) {
            case 'h': return usage(), 0;
            case 'V': return printf("%s\n", CHFREQ_VERSION), 0;
            case 'f': opt = *argv++; format = *argv++; break;
          }
          break;
      }
    }
  }

  if (NULL == format) {
    format = "%c | %d";
  }

  // get order of format
  {
    char ch = 0;
    int i = 0;
    while ('\0' != (ch = format[i++])) {
      if ('%' == ch) {
        if ('c' == format[i]) { cfirst = 1; break; }
        else { cfirst = 0; break; }
      }
    }
  }

  if (1 == isatty(0)) { return usage(), 1; }
  else if (ferror(stdin)) { return 1; }
  else {
    do {
      buf = read_stdin();
      if (NULL == buf) { return 1; }
      freq = chfreq(buf);
      for (int i = 0; (cur = freq[i]); ++i) {
        if (1 == cfirst) { printf(format, cur[0], cur[1]); }
        else { printf(format, cur[1], cur[0]); }
        printf("\n");
      }
    } while (NULL != buf);
  }
  return 0;
}

int main(int argc, const char *const *argv)
{
    struct timeval *tv, tvbuf;
    adns_query qu;
    void *qun_v;
    adns_answer *answer;
    int r, maxfd;
    fd_set readfds, writefds, exceptfds;
    const char *arg;

    ensure_adns_init();

    while ((arg= *++argv)) process_optarg(arg,&argv,0);

    if (!ov_pipe && !ads) usageerr("no domains given, and -f/--pipe not used; try --help");

    for (;;)
    {
        for (;;)
        {
            qu= ov_asynch ? 0 : outstanding.head ? outstanding.head->qu : 0;
            r= adns_check(ads,&qu,&answer,&qun_v);
            if ((r == EAGAIN) || (r == EWOULDBLOCK)) break;
            if (r == ESRCH)
            {
                if (!ov_pipe) goto x_quit;
                else break;
            }
            assert(!r);
            query_done(qun_v,answer);
        }
        maxfd= 0;
        FD_ZERO(&readfds);
        FD_ZERO(&writefds);
        FD_ZERO(&exceptfds);
        if (ov_pipe)
        {
            maxfd= 1;
            FD_SET(0,&readfds);
        }
        tv= 0;
        adns_beforeselect(ads, &maxfd, &readfds,&writefds,&exceptfds, &tv,&tvbuf,0);
        ADNS_CLEAR_ERRNO;
        r= select(maxfd, &readfds,&writefds,&exceptfds, tv);
        ADNS_CAPTURE_ERRNO;
        if (r == -1)
        {
            if (errno == EINTR) continue;
            sysfail("select",errno);
        }
        adns_afterselect(ads, maxfd, &readfds,&writefds,&exceptfds, 0);
        if (ov_pipe && FD_ISSET(0,&readfds)) read_stdin();
    }
x_quit:
    if (fclose(stdout)) outerr();
    quitnow(rcode);
}

int main(int argc, char *argv[])
{
    int sock;
    struct sockaddr_in addr;
    int port = get_port(argc, argv);
    char server_address_string[16];
    char buf[BUF_SIZE];
    char repeat = 1;
    int id;
    set_address(argc, argv, server_address_string, LENGTH_OF(server_address_string));

    srand(time(NULL));
    id = rand();

    sock = socket(AF_INET, SOCK_STREAM, 0);
    if(WRONG_SOC(sock)) {
        perror("socket");
        exit(1);
    }

    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    /* addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); */
    addr.sin_addr.s_addr = inet_addr(server_address_string);
    if(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("connect");
        exit(2);
    }

    printf("%s:%d, ID: %d\n", server_address_string, port, id);

    send(sock, &id, sizeof(id), EMPTY_FLAGS);

    while(repeat) {
        printf("-> ");
        read_stdin(buf, LENGTH_OF(buf));
        if(strlen(buf) == 0) continue;
        if(!strncmp(buf, "close", LENGTH_OF(buf))) repeat = 0;
        send_to(sock, buf);

        // download file if its exists
        if(strstr(buf, "download") && receive_int(sock)) {
            receive_file(sock);

            printf("%s\n", FILE_DOWNLOADED_MSG);
            continue;
        }

        // prints info or error mesages
        receive_and_print_msg(sock);
    }

    close(sock);

    return 0;
}

/* Cat clone */
int main(int argc, char **argv) {
  int i;
  if (argc < 2) {
    read_stdin();
    return 0;
  }
  for (i=1 ; i<argc ; i++) {
    print_file(argv[i]);
  }
  return 0;
}

int		check_fds(fd_set *fd_read, int *fd,
			  void (*fptr[7])(char buf[515], int *), char *tab[7])
{
  if (FD_ISSET(0, fd_read))
    if (read_stdin(fd, fptr, tab) == -1)
      return (-1);
  if (*fd != -1 && FD_ISSET(*fd, fd_read))
    if (read_socket(fd) == -1)
      return (-1);
  return (0);
}

static void MojoGui_stdio_msgbox(const char *title, const char *text)
{
    char buf[128];
    char *fmt = xstrdup(_("NOTICE: %0\n[hit enter]"));
    char *msg = format(fmt, text);
    printf("%s\n", msg);
    free(msg);
    free(fmt);
    fflush(stdout);
    read_stdin(buf, sizeof (buf));
} // MojoGui_stdio_msgbox

int		check_fd(t_env *e)
{
	if (FD_ISSET(e->fd.fd, &e->fd_read))
	{
		return (read_fd(e));
	}
	if (FD_ISSET(0, &e->fd_read))
	{
		read_stdin(e);
	}
	return (1);
}

int main(int argc, char** argv) {
	char* content;
	if (argc > 1) { content = argv[1]; }
	else { content = read_stdin(); }
	treebank_tokens_t* tokens = treebank_tokenize(content);
	int num_tokens = tokens->length;
	for (int i = 0; i < num_tokens; i++) printf("%s ", 
		tokens->token_array[i]);
	treebank_tokens_free(tokens);
	printf("\n");
	return 0;
}

int main(int argc, char **argv) {
	entry** table = mk_table();
	if (argc > 1 ) {
		for (int i=1; i < argc; i++) {
			read_file(argv[i], table);
		}
	} else {
		read_stdin(table);
	}
	print_table(table);
	del_table(table);
	return 0;
} 

static MojoGuiYNAN MojoGui_stdio_promptynan(const char *title, const char *txt,
                                            boolean defval)
{
    MojoGuiYNAN retval = MOJOGUI_NO;
    if (!feof(stdin))
    {
        char *fmt = xstrdup(_("%0\n[y/n/Always/Never]: "));
        char *msg = format(fmt, txt);
        char *localized_no = xstrdup(_("N"));
        char *localized_yes = xstrdup(_("Y"));
        char *localized_always = xstrdup(_("Always"));
        char *localized_never = xstrdup(_("Never"));
        boolean getout = false;
        char buf[128];

        while (!getout)
        {
            int rc = 0;

            getout = true;  // we may reset this later.
            printf("%s\n", msg);
            fflush(stdout);
            rc = read_stdin(buf, sizeof (buf));

            if (rc < 0)
                retval = MOJOGUI_NO;
            else if (rc == 0)
                retval = (defval) ? MOJOGUI_YES : MOJOGUI_NO;
            else if (strcasecmp(buf, localized_no) == 0)
                retval = MOJOGUI_NO;
            else if (strcasecmp(buf, localized_yes) == 0)
                retval = MOJOGUI_YES;
            else if (strcasecmp(buf, localized_always) == 0)
                retval = MOJOGUI_ALWAYS;
            else if (strcasecmp(buf, localized_never) == 0)
                retval = MOJOGUI_NEVER;
            else
                getout = false;  // try again.
        } // while

        free(localized_never);
        free(localized_always);
        free(localized_yes);
        free(localized_no);
        free(msg);
        free(fmt);
    } // if

    return retval;
} // MojoGui_stdio_promptynan

int
main(int argc , char * argv[])
{
	int ch;
	const char * proto = NULL;
	const char * message = NULL;
	const char * datafile = NULL;
	int mode = 0;
	while ((ch = getopt(argc, argv, "hDp:m:d:")) != -1) {
		switch(ch) {
		case 'h':
			usage(argv[0]);
			return 0;
		case 'p':
			proto = optarg;
			break;
		case 'm':
			message = optarg;
			break;
		case 'd':
			datafile = optarg;
			break;
		case 'D':
			mode = 10;
			break;
		default:
			usage(argv[0]);
			return 1;
		}
	}

	if (proto == NULL || message == NULL) {
		usage(argv[0]);
		return 1;
	}

	struct pbc_slice data;

	if (datafile == NULL) {
		read_stdin(mode, &data);
	} else {
		read_file(datafile , &data);
	}

	dump(proto , message , &data);

	return 0;
}

int main(int argc, char **argv)
{
	int n;
	char **in;
	char *path;

	option_parse(argc, argv);
	agurim_init();

	argc -= optind;
	argv += optind;

	if (argc == 0){
		/* stdin supports re-aggregation format only. */
		if (query.outfmt != REAGGREGATION) 
			usage();
		else
			read_stdin();
	}

again:
	n = argc;
	in = argv;

	while (n > 0) {
		path = *in;
		if (is_dir(path))
			read_dir(path);
		else
			read_file(path);
		++in;
		--n;
	}
	if (inparam.mode == HHH_MAIN_MODE){
		hhh_run();
		if (query.outfmt != REAGGREGATION) {
			/* reset internal parameters for text processing */
			param_set_nextmode();
			/* goto the second pass */
			goto again;
		}
	} else {
		plot_run();
	}
	agurim_finish();

	return (0);
}

static char *ask_password(void) {
  char *passwd, *r;

  passwd = malloc(128 + 1);
  if (passwd == NULL)
    return NULL;

  printf("[%s] Enter password: ", arg_username);

  r = read_stdin(passwd, 128, false);
  if (r == NULL) {
    free(passwd);
    return NULL;
  }

  return passwd;
}

void mgrep(const regex_t* preg, flags_t flags) {
    if (flags.mmap) {
	struct stat sb;
	if (fstat(0, &sb) == -1) {
	    perror ("fstat");
	    exit(1);
	}
	char *p =mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, 0, 0);
	if (p == MAP_FAILED) {
	    perror("mmap");
	    exit(1);
	}
	readlines(preg, p, sb.st_size);
	munmap(p,sb.st_size);
    } else {
	read_stdin(preg);
    }
}

static void
event_loop(void) {
	int xfd, nbits, dr=0;
	fd_set rmask;

	// Assign connection number for the specified display
	xfd = ConnectionNumber(dzen.dpy);
	while(dzen.running) {
		FD_ZERO(&rmask);	// Clear newly declared set
		FD_SET(xfd, &rmask);	// Assign the fd to a set
		if(dr != -2)	//TODO (PM) Won't this statement always return true?
			FD_SET(STDIN_FILENO, &rmask);
			//TODO (PM) This would make a second call to the same function.
			// Can more than one fd be assigned to a set?

		while(XPending(dzen.dpy))
			handle_xev();

		nbits = select(xfd+1, &rmask, NULL, NULL, NULL);
		if (nbits != -1) {
			//TODO (PM) Again, dr has only been assigned the value, zero
			if (dr != -2 && FD_ISSET(STDIN_FILENO, &rmask)) {
				if ((dr = read_stdin()) == -1)
					return;
				handle_newl();
			}
			if (dr == -2 && dzen.timeout > 0) {
				/* set an alarm to kill us after the timeout */
				struct itimerval t;
				memset(&t, 0, sizeof t);
				t.it_value.tv_sec = dzen.timeout;
				t.it_value.tv_usec = 0;
				setitimer(ITIMER_REAL, &t, NULL);
			}
			if (FD_ISSET(xfd, &rmask))
				handle_xev();
		}
		else {
			perror("select");	//TODO (PM) Consolidate error handling
			exit(EXIT_FAILURE);
		}
	}
	return;
}