#ifndef _LIB_TIME_MAP_HEADER_H
#define _LIB_TIME_MAP_HEADER_H

#include "lib_macros.h"
#include "time_header.h"

void lib_tzset(void);

timezone_t ASM lib_tzalloc(
    REG(a0, char const *name)
);

void ASM lib_tzfree(
    REG(a0,timezone_t tz)
);

time_t ASM lib_time(
    REG(a0, time_t *tloc)
);

time_t ASM lib_mktime(
    REG(a0, struct tm *)
);

time_t ASM lib_mktime_z(
    REG(a1, const timezone_t tz),
    REG(a0, struct tm *)
);

struct tm* ASM lib_localtime(
    REG(a0, const time_t *const timep)
);

struct tm* ASM lib_localtime_r(
    REG(a0, const time_t *const timep),
    REG(a1, struct tm *tmp)
);

struct tm* ASM lib_localtime_rz(
    REG(a2, timezone_t tz),
    REG(a0, const time_t *const timep),
    REG(a1, struct tm *tmp)
);

struct tm* ASM lib_gmtime(
    REG(a0, const time_t *timep)
);

struct tm* ASM lib_gmtime_r(
    REG(a0, const time_t *timep),
    REG(a1, struct tm *tmp)
);

time_t ASM lib_timegm(
    REG(a0, struct tm *const tmp)
);

time_t ASM lib_timelocal(
    REG(a0, struct tm *const tmp)
);

time_t ASM lib_timelocal_z(
    REG(a1, const timezone_t tz),
    REG(a0, struct tm *const tmp)
);

double ASM lib_difftime(
    REG(d1, const time_t time1),
    REG(d0, const time_t time0)
);

struct tm* ASM lib_offtime(
    REG(a0, const time_t *const timep),
    REG(d0, long offset)
);

struct tm* ASM lib_offtime_r(
    REG(a0, const time_t *timep),
    REG(d0, long offset),
    REG(a1, struct tm *tmp)
);

time_t ASM lib_timeoff(
    REG(a0, struct tm *const tmp),
    REG(d0, long offset)
);

char* ASM lib_ctime(
    REG(a0, const time_t *const timep)
);

char* ASM lib_ctime_r(
    REG(a0, const time_t *const timep),
    REG(a1, char *buf)
);

char* ASM lib_ctime_rz(
    REG(a2, const timezone_t tz),
    REG(a0, const time_t *const timep),
    REG(a1, char *buf)
);

char* ASM lib_asctime(
    REG(a0, const struct tm *timeptr)
);

char* ASM lib_asctime_r(
    REG(a0,const struct tm *timeptr),
    REG(a1,char *buf)
);

size_t ASM lib_strftime(
    REG(a0, char * const s),
    REG(d0, size_t maxsize),
    REG(a1, const char *const format),
    REG(a2, const struct tm *const t)
);

size_t ASM lib_strftime_l(
    REG(a0, char *s),
    REG(d0, size_t maxsize),
    REG(a1, char const *format),
    REG(a2, const struct tm *const t),
    REG(a3, locale_t locale)
);

char* ASM lib_strptime(
    REG(a0, const char *buf),
    REG(a1, const char *fmt),
    REG(a2, struct tm *tm)
);

char* ASM lib_strptime_l(
    REG(a0, const char *buf),
    REG(a1, const char *fmt),
    REG(a2, struct tm *tm),
    REG(a3, locale_t locale)
);

time_t ASM lib_time2posix(
    REG(d0, time_t t)
);

time_t ASM lib_time2posix_z(
    REG(a0, timezone_t tz),
    REG(d0, time_t t)
);

time_t ASM lib_posix2time(
    REG(d0, time_t t)
);

time_t ASM lib_posix2time_z(
    REG(a0, timezone_t tz),
    REG(d0, time_t t)
);

int ASM lib_daylight_c(void);
long ASM lib_timezone_c(void);
long ASM lib_altzone_c(void);
char** ASM lib_tzname_c(void);

int ASM lib_getsystime(
    REG(a0, struct timeval *tv)
);

int ASM lib_setsystime(
    REG(a0, struct timeval *tv)
);

int ASM lib_gettimeofday(
    REG(a0, struct timeval *tv),
    REG(a1, const timezone_t tz)
);

int ASM lib_settimeofday(
    REG(a0, const struct timeval *tv),
    REG(a1, const timezone_t tz)
);

int ASM lib_gmtoffset(
    REG(d0, time_t locale_time)
);

void lib_tzsetwall(void);

const char* ASM lib_tzgetlocation(void);

const char* ASM lib_tzgetname(
    REG(a0, const timezone_t tz),
    REG(d0, int isdst)
);

void ASM lib_stou(
    REG(a0, char *s)
);

void ASM lib_utos(
    REG(a0, char *s)
);

#endif