static struct struo_Options global_options;

static void data_file_read_error(void *ud) {
}
static void data_file_read_partial(void *ud, const void *data, uint64_t length) {
  printf("%.*s", (int)(length), (const char *)data);
}
static void data_file_read_done(void *ud) {
}

void data_paths_find_error(void *ud) {

static void data_paths_find_error(void *ud) {

void data_paths_find_found(void *ud, alias_str path) {

static void data_paths_find_found(void *ud, alias_str path) {

  alias_DirectoryList_read(&global_options.data_paths, path, data_file_read_error, data_file_read_partial, data_file_read_done, NULL);

void data_paths_find_done_show_files(void *ud) {

static void data_paths_find_done_show_files(void *ud) {

  static struct struo_Options options;

  struo_Options_init(&options);

  struo_Options_init(&global_options);

      struo_Options_add_asset_path(&options, argv[i++]);

      struo_Options_add_asset_path(&global_options, argv[i++]);

      struo_Options_add_data_path(&options, argv[i++]);

      struo_Options_add_data_path(&global_options, argv[i++]);

        struo_Options_set_build_path(&options, argv[i++]);

        struo_Options_set_build_path(&global_options, argv[i++]);

        struo_Options_set_output_path(&options, argv[i++]);

        struo_Options_set_output_path(&global_options, argv[i++]);

  alias_DirectoryList_find(&options.data_paths, "*.txt", data_paths_find_error, data_paths_find_found, data_paths_find_done_show_files, NULL);

  alias_DirectoryList_find(&global_options.data_paths, "*.txt", data_paths_find_error, data_paths_find_found, data_paths_find_done_show_files, NULL);

  uv_pipe_t pipe;

  uint8_t buffer[1 << 12];

  uv_fs_req_cleanup(req);

static void FileRead_close_cb(uv_handle_t *handle) {
  struct FileRead *state = (struct FileRead *)uv_handle_get_data(handle);
  uv_fs_close(alias_libuv_event_loop(), &state->req, state->fd, FileRead_fs_close_cb);
}
static void FileRead_alloc_cb(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
  buf->base = alias_malloc(NULL, suggested_size, 4);
  buf->len = suggested_size;
}
static void FileRead_read_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
  struct FileRead *state = (struct FileRead *)uv_handle_get_data((uv_handle_t *)stream);
  if(nread == UV_EOF) {

static void FileRead_fs_read_execute(struct FileRead *state);
static void FileRead_fs_read_cb(uv_fs_t *req) {
  struct FileRead *state = (struct FileRead *)uv_req_get_data((uv_req_t *)req);
  if(req->result == 0) {

    goto stop;
  } else if(nread < 0) {

    uv_fs_req_cleanup(req);
    uv_fs_close(alias_libuv_event_loop(), &state->req, state->fd, FileRead_fs_close_cb);
  } else if(req->result < 0) {

  stop:
    uv_read_stop(stream);
    uv_close((uv_handle_t *)stream, FileRead_close_cb);
  } else if(buf->base != NULL) {
    state->partial(state->ud, buf->base, buf->len);
    alias_free(NULL, buf->base, buf->len, 4);

    uv_fs_req_cleanup(req);
    uv_fs_close(alias_libuv_event_loop(), &state->req, state->fd, FileRead_fs_close_cb);
  } else {
    state->partial(state->ud, state->buffer, req->result);
    uv_fs_req_cleanup(req);
    FileRead_fs_read_execute(state);

}
static void FileRead_fs_read_execute(struct FileRead *state) {
  uv_buf_t buf;
  buf.base = (void *)state->buffer;
  buf.len = sizeof(state->buffer);
  uv_fs_read(alias_libuv_event_loop(), &state->req, state->fd, &buf, 1, -1, FileRead_fs_read_cb);

  uv_pipe_init(alias_libuv_event_loop(), &state->pipe, 0);
  uv_pipe_open(&state->pipe, state->fd);
  uv_handle_set_data((uv_handle_t *)&state->pipe, state);
  uv_read_start((uv_stream_t *)&state->pipe, FileRead_alloc_cb, FileRead_read_cb);

  FileRead_fs_read_execute(state);

      current->read_all_synchronous(current->ud, state->path, &ptr, &length);

      current->read_all_synchronous(current->ud, state->path, NULL, &ptr, &length);

      alias_free(NULL, ptr, length, 4);

    current = &state->dir->paths.data[--state->index];

    state->index--;
    current = &state->dir->paths.data[state->index];

      alias_file_exists(path, DirectoryListExists_cb, state_);

      alias_file_exists(path, DirectoryListRead_exists_cb, state_);

  	tabula_snprintf(ptr__, length__, length__, FORMAT, ## __VA_ARGS__); \

  	tabula_snprintf(ptr__, length__ + 1, length__ + 1, FORMAT, ## __VA_ARGS__); \

  	tabula_vsnprintf(ptr__, length__, length__, FORMAT, ptr_ap__); \

  	tabula_vsnprintf(ptr__, length__ + 1, length__ + 1, FORMAT, ptr_ap__); \

  void (*read_all_synchronous)(void *ud, alias_str path, void **data_ptr, uint64_t *length_ptr);

  void (*read_all_synchronous)(void *ud, alias_str path, alias_MemoryCB *mcb, void **data_ptr, uint64_t *length_ptr);

void alias_DirectoryList_read(const struct alias_DirectoryList *dir, alias_str path, void (*error)(void *ud),
                              void (*partial)(void *ud, const void *data, uint64_t length), void (*done)(void *ud),
                              void *ud);