代码

#include <stdarg.h>
typedef unsigned long size_t;
struct DuckInfo {
    unsigned long abi_version; const char *stdin_ptr; unsigned long stdin_size;
    char *stdout_ptr; unsigned long stdout_limit; unsigned long stdout_size;
    char *stderr_ptr; unsigned long stderr_limit; unsigned long stderr_size;
    const char *IB_ptr; unsigned long IB_limit; char *OB_ptr; unsigned long OB_limit;
    unsigned long tsc_frequency;
} __attribute__((packed));

static unsigned long* g_di = 0;
static const char* in_cursor;
static char* out_cursor;
static char* out_base;
static void flush_size(void){ if (g_di) g_di[5] = (unsigned long)(out_cursor - out_base); }
static void putc_fast(char c){ *out_cursor++ = c; flush_size(); }
static int getc_fast(void){ return (*in_cursor == 0) ? -1 : (int)(unsigned char)*in_cursor++; }

static void print_int(long long v){
    unsigned long long u;
    if (v < 0){ putc_fast('-'); u = (unsigned long long)(-(v+1)) + 1ULL; }
    else u = (unsigned long long)v;
    char tmp[24]; int n=0;
    do { tmp[n++]=(char)('0'+(int)(u%10)); u/=10; } while(u);
    while(n) putc_fast(tmp[--n]);
}

static int vprintf_impl(const char *fmt, va_list ap){
    const char *f=fmt; int count=0;
    while(*f){
        if(*f!='%'){ putc_fast(*f++); count++; continue; }
        f++;
        while(*f=='-'||*f=='+'||*f==' '||*f=='#'||*f=='0') f++;
        while(*f>='0'&&*f<='9') f++;
        int prec=-1;
        if(*f=='.'){ f++; prec=0; while(*f>='0'&&*f<='9'){ prec=prec*10+(*f-'0'); f++; } }
        int is_ll=0;
        if(*f=='l'){ f++; if(*f=='l'){ is_ll=1; f++; } }
        else if(*f=='h'||*f=='j'||*f=='z'||*f=='t') f++;
        char c=*f++;
        if(c=='d'||c=='i'){ long long v=is_ll?va_arg(ap,long long):(long long)va_arg(ap,int); print_int(v); count+=8; }
        else if(c=='u'||c=='x'||c=='X'||c=='o'){ unsigned long long v=is_ll?va_arg(ap,unsigned long long):(unsigned long long)va_arg(ap,unsigned int); print_int((long long)v); count+=8; }
        else if(c=='s'){ const char *s=va_arg(ap,const char*); while(*s){ putc_fast(*s++); count++; } }
        else if(c=='c'){ putc_fast((char)va_arg(ap,int)); count++; }
        else if(c=='p'){ print_int((long long)(unsigned long)va_arg(ap,void*)); count+=8; }
        else if(c=='%'){ putc_fast('%'); count++; }
        else { putc_fast(c); count++; }
    }
    flush_size();
    return count;
}

extern "C" int printf(const char *fmt, ...){ va_list ap; va_start(ap,fmt); int r=vprintf_impl(fmt,ap); va_end(ap); return r; }
extern "C" int vprintf(const char *fmt, va_list ap){ return vprintf_impl(fmt,ap); }
extern "C" int fprintf(void *f, const char *fmt, ...){ va_list ap; va_start(ap,fmt); int r=vprintf_impl(fmt,ap); va_end(ap); return r; }
extern "C" int vfprintf(void *f, const char *fmt, va_list ap){ return vprintf_impl(fmt,ap); }
extern "C" int sprintf(char *buf, const char *fmt, ...){ return 0; }
extern "C" int snprintf(char *buf, size_t n, const char *fmt, ...){ return 0; }

extern "C" int putchar(int c){ putc_fast((char)c); return c; }
extern "C" int putc(int c, void *f){ return putchar(c); }
extern "C" int fputc(int c, void *f){ return putchar(c); }
extern "C" int puts(const char *s){ while(*s) putc_fast(*s++); putc_fast('\n'); return 0; }
extern "C" int fputs(const char *s, void *f){ while(*s) putc_fast(*s++); return 0; }
extern "C" size_t fwrite(const void *p, size_t sz, size_t n, void *f){ const char *s=(const char*)p; size_t t=sz*n; for(size_t i=0;i<t;i++) putc_fast(s[i]); return n; }
extern "C" int fflush(void *f){ return 0; }

static long long parse_int(void){
    const char *p=in_cursor;
    while(*p==' '||*p=='\t'||*p=='\n'||*p=='\r') p++;
    int neg=0; if(*p=='-'){neg=1;p++;} else if(*p=='+') p++;
    unsigned long long v=0;
    while(*p>='0'&&*p<='9'){ v=v*10+(unsigned)(*p-'0'); p++; }
    in_cursor=p;
    return neg?-(long long)v:(long long)v;
}
static int vscanf_impl(const char *fmt, va_list ap){
    const char *f=fmt; int ret=0;
    while(*f){
        unsigned char fc=(unsigned char)*f;
        if(fc==' '||fc=='\t'||fc=='\n'||fc=='\r'){ while(*in_cursor==' '||*in_cursor=='\t'||*in_cursor=='\n'||*in_cursor=='\r') in_cursor++; f++; }
        else if(fc!='%'){ if(*in_cursor==fc) in_cursor++; f++; }
        else{
            f++; int is_l=0,is_ll=0;
            if(*f=='l'){ is_l=1; f++; if(*f=='l'){ is_ll=1; f++; } }
            else if(*f=='h') f++;
            char c=*f++;
            if(c=='d'||c=='i'){ long long v=parse_int(); if(is_ll)*va_arg(ap,long long*)=v; else if(is_l)*va_arg(ap,long*)=(long)v; else *va_arg(ap,int*)=(int)v; ret++; }
            else if(c=='u'||c=='x'||c=='X'){ long long v=parse_int(); if(is_ll)*va_arg(ap,unsigned long long*)=(unsigned long long)v; else *va_arg(ap,unsigned*)=(unsigned)v; ret++; }
            else if(c=='c'){ *va_arg(ap,char*)=(char)getc_fast(); ret++; }
            else if(c=='s'){ char *s=va_arg(ap,char*); int ch; while((ch=getc_fast())>0 && ch!=' '&&ch!='\n'&&ch!='\t'){ *s++=(char)ch; } *s=0; ret++; }
        }
    }
    return ret;
}
extern "C" int scanf(const char *fmt, ...){ va_list ap; va_start(ap,fmt); int r=vscanf_impl(fmt,ap); va_end(ap); return r; }
extern "C" int vscanf(const char *fmt, va_list ap){ return vscanf_impl(fmt,ap); }
extern "C" int fscanf(void *f, const char *fmt, ...){ va_list ap; va_start(ap,fmt); int r=vscanf_impl(fmt,ap); va_end(ap); return r; }
extern "C" int vfscanf(void *f, const char *fmt, va_list ap){ return vscanf_impl(fmt,ap); }
extern "C" int getchar(void){ return getc_fast(); }
extern "C" int getc(void *f){ return getc_fast(); }
extern "C" int fgetc(void *f){ return getc_fast(); }
extern "C" char *fgets(char *s, int size, void *f){ int i=0; while(i<size-1){ int c=getc_fast(); if(c<0)break; s[i++]=(char)c; if(c=='\n')break; } s[i]=0; return (i>0)?s:(char*)0; }
extern "C" size_t fread(void *p, size_t sz, size_t n, void *f){ char *d=(char*)p; size_t t=sz*n; size_t i=0; for(;i<t;i++){ int c=getc_fast(); if(c<0)break; d[i]=(char)c; } return i/sz; }

static char heap[262144];
static size_t heap_pos=0;
extern "C" void *malloc(size_t n){ n=(n+15)&~15UL; void *p=heap+heap_pos; heap_pos+=n; return p; }
extern "C" void *calloc(size_t n, size_t m){ size_t t=n*m; void *p=malloc(t); for(size_t i=0;i<t;i++) ((char*)p)[i]=0; return p; }
extern "C" void *realloc(void *p, size_t n){ (void)p; return malloc(n); }
extern "C" void free(void *p){ (void)p; }

static void duck_exit(int code){
    flush_size();
    __asm__ volatile("syscall" : : "a"(60), "D"(code) : "rcx","r11","memory");
    __builtin_unreachable();
}
extern "C" void exit(int code){ duck_exit(code); }
extern "C" void _exit(int code){ duck_exit(code); }
extern "C" void _Exit(int code){ duck_exit(code); }

extern "C" void (*__preinit_array_start[])();
extern "C" void (*__preinit_array_end[])();
extern "C" void (*__init_array_start[])();
extern "C" void (*__init_array_end[])();

extern "C" void __libc_start_main(int (*main_fn)(int,char**,char**), int argc, char **argv,
                                   void (*init)(void), void (*fini)(void), void (*ldso)(void)){
    (void)init;(void)fini;(void)ldso;
    char **p=argv+argc+1;
    while(*p) p++;
    p++;
    unsigned long *auxv=(unsigned long*)p;
    while(auxv[0]!=0){ if(auxv[0]==0x6b637564ULL){ g_di=(unsigned long*)auxv[1]; break; } auxv+=2; }
    in_cursor=(const char*)g_di[1];
    out_base=(char*)g_di[3];
    out_cursor=out_base;
    for(void (**q)()=__preinit_array_start; q<__preinit_array_end; q++) (*q)();
    for(void (**q)()=__init_array_start; q<__init_array_end; q++) (*q)();
    int r=main_fn(argc, argv, (char**)0);
    duck_exit(r);
}

int plus(int a, int b){ return a+b; }

评测结果