/* -*- mode: C; buffer-read-only: t -*-
 *
 *    long_names.c
 *
 *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
 *    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
 *    2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025,
 *    2026 by Larry Wall and others
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 * !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
 * This file is built by regen/embed.pl from embed.fnc, intrpvar.h,
 * perlvars.h, regen/opcodes, regen/embed.pl, regen/embed_lib.pl and
 * regen/HeaderParser.pm.
 * Any changes made here will be lost!
 *
 * Edit those files and run 'make regen_headers' to effect changes.
 */

/* This file is automatically generated by embed.pl.
 *
 * Its current purpose is to contain functions that are automatically
 * generated synonyms for macros for which such a synonym has been requested,
 * and for which a function is necessary.  The synonym's name is the name of
 * the macro prefixed by 'Perl_'.  In some cases, such a synonym can be
 * handled by just using a macro defined to be the short name.  Those synonyms
 * are kept out of this file by embed.pl.
 *
 * To request a synonym, add the 'p' flag to the macro's entry in embed.fnc,
 * or to its "=for apidoc" line whereever that is. */

#include "EXTERN.h"
#define PERL_IN_LONG_NAMES_C
#include "perl.h"

#if !defined(USE_ITHREADS)
void
Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv)
{
    PERL_ARGS_ASSERT_COPFILEGV_SET;

    CopFILEGV_set(c, gv);
}
#endif

void
Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SVREFCNT_DEC_SET_NULL;

    SvREFCNT_dec_set_NULL(sv);
}

bool
Perl_c9strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p)
{
    PERL_ARGS_ASSERT_C9STRICT_UTF8_TO_UV;

    return c9strict_utf8_to_uv(s, e, cp_p, advance_p);
}

bool
Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp)
{
    PERL_ARGS_ASSERT_DO_OPEN;

    return do_open(gv, name, len, as_raw, rawmode, rawperm, supplied_fp);
}

Size_t
Perl_expected_size(UV size)
{
    PERL_ARGS_ASSERT_EXPECTED_SIZE;

    return expected_size(size);
}

bool
Perl_extended_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p)
{
    PERL_ARGS_ASSERT_EXTENDED_UTF8_TO_UV;

    return extended_utf8_to_uv(s, e, cp_p, advance_p);
}

I32
Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)
{
    PERL_ARGS_ASSERT_FOLDEQ_UTF8;

    return foldEQ_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2);
}

GV *
Perl_gv_AVadd(pTHX_ GV *gv)
{
    PERL_ARGS_ASSERT_GV_AVADD;

    return gv_AVadd(gv);
}

GV *
Perl_gv_HVadd(pTHX_ GV *gv)
{
    PERL_ARGS_ASSERT_GV_HVADD;

    return gv_HVadd(gv);
}

GV *
Perl_gv_IOadd(pTHX_ GV *gv)
{
    PERL_ARGS_ASSERT_GV_IOADD;

    return gv_IOadd(gv);
}

GV *
Perl_gv_SVadd(pTHX_ GV *gv)
{
    PERL_ARGS_ASSERT_GV_SVADD;

    return gv_SVadd(gv);
}

void
Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
{
    PERL_ARGS_ASSERT_GV_EFULLNAME3;

    gv_efullname3(sv, gv, prefix);
}

GV *
Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
{
    PERL_ARGS_ASSERT_GV_FETCHMETH;

    return gv_fetchmeth(stash, name, len, level);
}

GV *
Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
{
    PERL_ARGS_ASSERT_GV_FETCHMETH_AUTOLOAD;

    return gv_fetchmeth_autoload(stash, name, len, level);
}

GV *
Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
{
    PERL_ARGS_ASSERT_GV_FETCHMETHOD;

    return gv_fetchmethod(stash, name);
}

void
Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
{
    PERL_ARGS_ASSERT_GV_FULLNAME3;

    gv_fullname3(sv, gv, prefix);
}

void
Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi)
{
    PERL_ARGS_ASSERT_GV_INIT;

    gv_init(gv, stash, name, len, multi);
}

SV *
Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags)
{
    PERL_ARGS_ASSERT_HV_DELETE;

    return hv_delete(hv, key, klen, flags);
}

SV *
Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash)
{
    PERL_ARGS_ASSERT_HV_DELETE_ENT;

    return hv_delete_ent(hv, keysv, flags, hash);
}

bool
Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen)
{
    PERL_ARGS_ASSERT_HV_EXISTS;

    return hv_exists(hv, key, klen);
}

bool
Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
{
    PERL_ARGS_ASSERT_HV_EXISTS_ENT;

    return hv_exists_ent(hv, keysv, hash);
}

SV **
Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval)
{
    PERL_ARGS_ASSERT_HV_FETCH;

    return hv_fetch(hv, key, klen, lval);
}

HE *
Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash)
{
    PERL_ARGS_ASSERT_HV_FETCH_ENT;

    return hv_fetch_ent(hv, keysv, lval, hash);
}

HE *
Perl_hv_iternext(pTHX_ HV *hv)
{
    PERL_ARGS_ASSERT_HV_ITERNEXT;

    return hv_iternext(hv);
}

void
Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
{
    PERL_ARGS_ASSERT_HV_MAGIC;

    hv_magic(hv, gv, how);
}

SV **
Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash)
{
    PERL_ARGS_ASSERT_HV_STORE;

    return hv_store(hv, key, klen, val, hash);
}

HE *
Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash)
{
    PERL_ARGS_ASSERT_HV_STORE_ENT;

    return hv_store_ent(hv, key, val, hash);
}

SV **
Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags)
{
    PERL_ARGS_ASSERT_HV_STORE_FLAGS;

    return hv_store_flags(hv, key, klen, val, hash, flags);
}

void
Perl_hv_undef(pTHX_ HV *hv)
{
    PERL_ARGS_ASSERT_HV_UNDEF;

    hv_undef(hv);
}

I32
Perl_ibcmp(pTHX_ const char *a, const char *b, I32 len)
{
    PERL_ARGS_ASSERT_IBCMP;

    return ibcmp(a, b, len);
}

I32
Perl_ibcmp_locale(pTHX_ const char *a, const char *b, I32 len)
{
    PERL_ARGS_ASSERT_IBCMP_LOCALE;

    return ibcmp_locale(a, b, len);
}

I32
Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2)
{
    PERL_ARGS_ASSERT_IBCMP_UTF8;

    return ibcmp_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2);
}

char *
Perl_instr(const char *big, const char *little)
{
    PERL_ARGS_ASSERT_INSTR;

    return instr(big, little);
}

bool
Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len)
{
    PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING;

    return is_c9strict_utf8_string(s, len);
}

bool
Perl_is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep)
{
    PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOC;

    return is_c9strict_utf8_string_loc(s, len, ep);
}

bool
Perl_is_strict_utf8_string(const U8 *s, STRLEN len)
{
    PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING;

    return is_strict_utf8_string(s, len);
}

bool
Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep)
{
    PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOC;

    return is_strict_utf8_string_loc(s, len, ep);
}

STRLEN
Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end)
{
    PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF;

    return is_utf8_char_buf(buf, buf_end);
}

bool
Perl_is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags)
{
    PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_FLAGS;

    return is_utf8_fixed_width_buf_flags(s, len, flags);
}

bool
Perl_is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags)
{
    PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOC_FLAGS;

    return is_utf8_fixed_width_buf_loc_flags(s, len, ep, flags);
}

bool
Perl_is_utf8_string(const U8 *s, STRLEN len)
{
    PERL_ARGS_ASSERT_IS_UTF8_STRING;

    return is_utf8_string(s, len);
}

bool
Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep)
{
    PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC;

    return is_utf8_string_loc(s, len, ep);
}

bool
Perl_is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags)
{
    PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC_FLAGS;

    return is_utf8_string_loc_flags(s, len, ep, flags);
}

bool
Perl_is_utf8_valid_partial_char(const U8 * const s0, const U8 * const e)
{
    PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR;

    return is_utf8_valid_partial_char(s0, e);
}

CV *
Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
{
    PERL_ARGS_ASSERT_NEWATTRSUB;

    return newATTRSUB(floor, o, proto, attrs, block);
}

AV *
Perl_newAV(pTHX)
{
    PERL_ARGS_ASSERT_NEWAV;

    return newAV();
}

AV *
Perl_newAV_alloc_x(pTHX_ SSize_t size)
{
    PERL_ARGS_ASSERT_NEWAV_ALLOC_X;

    return newAV_alloc_x(size);
}

AV *
Perl_newAV_alloc_xz(pTHX_ SSize_t size)
{
    PERL_ARGS_ASSERT_NEWAV_ALLOC_XZ;

    return newAV_alloc_xz(size);
}

AV *
Perl_newAV_mortal(pTHX)
{
    PERL_ARGS_ASSERT_NEWAV_MORTAL;

    return newAV_mortal();
}

GV *
Perl_newGVgen(pTHX_ const char *pack)
{
    PERL_ARGS_ASSERT_NEWGVGEN;

    return newGVgen(pack);
}

HV *
Perl_newHV(pTHX)
{
    PERL_ARGS_ASSERT_NEWHV;

    return newHV();
}

IO *
Perl_newIO(pTHX)
{
    PERL_ARGS_ASSERT_NEWIO;

    return newIO();
}

CV *
Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
{
    PERL_ARGS_ASSERT_NEWSUB;

    return newSUB(floor, o, proto, block);
}

SV *
Perl_newSVsv(pTHX_ SV * const old)
{
    PERL_ARGS_ASSERT_NEWSVSV;

    return newSVsv(old);
}

SV *
Perl_newSVsv_nomg(pTHX_ SV * const old)
{
    PERL_ARGS_ASSERT_NEWSVSV_NOMG;

    return newSVsv_nomg(old);
}

OP *
Perl_op_lvalue(pTHX_ OP *o, I32 type)
{
    PERL_ARGS_ASSERT_OP_LVALUE;

    return op_lvalue(o, type);
}

const char *
Perl_phase_name(pTHX_ enum perl_phase phase)
{
    PERL_ARGS_ASSERT_PHASE_NAME;

    return phase_name(phase);
}

void
Perl_qerror(pTHX_ SV *err)
{
    PERL_ARGS_ASSERT_QERROR;

    qerror(err);
}

void
Perl_resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer)
{
    PERL_ARGS_ASSERT_RESUME_COMPCV_AND_SAVE;

    resume_compcv_and_save(buffer);
}

void
Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer)
{
    PERL_ARGS_ASSERT_RESUME_COMPCV_FINAL;

    resume_compcv_final(buffer);
}

void
Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr)
{
    PERL_ARGS_ASSERT_SAVE_AELEM;

    save_aelem(av, idx, sptr);
}

void
Perl_save_freeop(pTHX_ OP *o)
{
    PERL_ARGS_ASSERT_SAVE_FREEOP;

    save_freeop(o);
}

void
Perl_save_freepv(pTHX_ char *pv)
{
    PERL_ARGS_ASSERT_SAVE_FREEPV;

    save_freepv(pv);
}

void
Perl_save_freesv(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SAVE_FREESV;

    save_freesv(sv);
}

void
Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr)
{
    PERL_ARGS_ASSERT_SAVE_HELEM;

    save_helem(hv, key, sptr);
}

void
Perl_save_mortalizesv(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SAVE_MORTALIZESV;

    save_mortalizesv(sv);
}

void
Perl_save_op(pTHX)
{
    PERL_ARGS_ASSERT_SAVE_OP;

    save_op();
}

bool
Perl_strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p)
{
    PERL_ARGS_ASSERT_STRICT_UTF8_TO_UV;

    return strict_utf8_to_uv(s, e, cp_p, advance_p);
}

bool
Perl_sv_2bool(pTHX_ SV * const sv)
{
    PERL_ARGS_ASSERT_SV_2BOOL;

    return sv_2bool(sv);
}

IV
Perl_sv_2iv(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_2IV;

    return sv_2iv(sv);
}

char *
Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp)
{
    PERL_ARGS_ASSERT_SV_2PV;

    return sv_2pv(sv, lp);
}

char *
Perl_sv_2pv_nolen(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_2PV_NOLEN;

    return sv_2pv_nolen(sv);
}

char *
Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp)
{
    PERL_ARGS_ASSERT_SV_2PVBYTE;

    return sv_2pvbyte(sv, lp);
}

char *
Perl_sv_2pvbyte_nolen(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN;

    return sv_2pvbyte_nolen(sv);
}

char *
Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp)
{
    PERL_ARGS_ASSERT_SV_2PVUTF8;

    return sv_2pvutf8(sv, lp);
}

char *
Perl_sv_2pvutf8_nolen(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN;

    return sv_2pvutf8_nolen(sv);
}

UV
Perl_sv_2uv(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_2UV;

    return sv_2uv(sv);
}

void
Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len)
{
    PERL_ARGS_ASSERT_SV_CATPVN;

    sv_catpvn(dsv, sstr, len);
}

void
Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len)
{
    PERL_ARGS_ASSERT_SV_CATPVN_MG;

    sv_catpvn_mg(dsv, sstr, len);
}

void
Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr)
{
    PERL_ARGS_ASSERT_SV_CATSV;

    sv_catsv(dsv, sstr);
}

void
Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr)
{
    PERL_ARGS_ASSERT_SV_CATSV_MG;

    sv_catsv_mg(dsv, sstr);
}

#if defined(USE_LOCALE_COLLATE)
char *
Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp)
{
    PERL_ARGS_ASSERT_SV_COLLXFRM;

    return sv_collxfrm(sv, nxp);
}
#endif

void
Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv)
{
    PERL_ARGS_ASSERT_SV_COPYPV;

    sv_copypv(dsv, ssv);
}

void
Perl_sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv)
{
    PERL_ARGS_ASSERT_SV_COPYPV_NOMG;

    sv_copypv_nomg(dsv, ssv);
}

I32
Perl_sv_eq(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_EQ;

    return sv_eq(sv1, sv2);
}

void
Perl_sv_force_normal(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_FORCE_NORMAL;

    sv_force_normal(sv);
}

void
Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen)
{
    PERL_ARGS_ASSERT_SV_INSERT;

    sv_insert(bigstr, offset, len, little, littlelen);
}

SV *
Perl_sv_mortalcopy(pTHX_ SV * const oldsv)
{
    PERL_ARGS_ASSERT_SV_MORTALCOPY;

    return sv_mortalcopy(oldsv);
}

I32
Perl_sv_numcmp(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_NUMCMP;

    return sv_numcmp(sv1, sv2);
}

bool
Perl_sv_numeq(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_NUMEQ;

    return sv_numeq(sv1, sv2);
}

bool
Perl_sv_numge(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_NUMGE;

    return sv_numge(sv1, sv2);
}

bool
Perl_sv_numgt(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_NUMGT;

    return sv_numgt(sv1, sv2);
}

bool
Perl_sv_numle(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_NUMLE;

    return sv_numle(sv1, sv2);
}

bool
Perl_sv_numlt(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_NUMLT;

    return sv_numlt(sv1, sv2);
}

bool
Perl_sv_numne(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_NUMNE;

    return sv_numne(sv1, sv2);
}

char *
Perl_sv_pv(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_PV;

    return sv_pv(sv);
}

char *
Perl_sv_pvbyte(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_PVBYTE;

    return sv_pvbyte(sv);
}

char *
Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp)
{
    PERL_ARGS_ASSERT_SV_PVN_FORCE;

    return sv_pvn_force(sv, lp);
}

char *
Perl_sv_pvutf8(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_PVUTF8;

    return sv_pvutf8(sv);
}

void
Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv)
{
    PERL_ARGS_ASSERT_SV_SETSV;

    sv_setsv(dsv, ssv);
}

bool
Perl_sv_streq(pTHX_ SV *sv1, SV *sv2)
{
    PERL_ARGS_ASSERT_SV_STREQ;

    return sv_streq(sv1, sv2);
}

void
Perl_sv_taint(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_TAINT;

    sv_taint(sv);
}

void
Perl_sv_unref(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_UNREF;

    sv_unref(sv);
}

void
Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len)
{
    PERL_ARGS_ASSERT_SV_USEPVN;

    sv_usepvn(sv, ptr, len);
}

void
Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len)
{
    PERL_ARGS_ASSERT_SV_USEPVN_MG;

    sv_usepvn_mg(sv, ptr, len);
}

bool
Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok)
{
    PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE;

    return sv_utf8_downgrade(sv, fail_ok);
}

bool
Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok)
{
    PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_NOMG;

    return sv_utf8_downgrade_nomg(sv, fail_ok);
}

STRLEN
Perl_sv_utf8_upgrade(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_UTF8_UPGRADE;

    return sv_utf8_upgrade(sv);
}

STRLEN
Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags)
{
    PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS;

    return sv_utf8_upgrade_flags(sv, flags);
}

STRLEN
Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv)
{
    PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_NOMG;

    return sv_utf8_upgrade_nomg(sv);
}

UV
Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp)
{
    PERL_ARGS_ASSERT_TO_UNI_FOLD;

    return to_uni_fold(c, p, lenp);
}

U8 *
Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 * const start)
{
    PERL_ARGS_ASSERT_UTF8_HOP_BACK;

    return utf8_hop_back(s, off, start);
}

U8 *
Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 * const end)
{
    PERL_ARGS_ASSERT_UTF8_HOP_FORWARD;

    return utf8_hop_forward(s, off, end);
}

U8 *
Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 * const start, const U8 * const end)
{
    PERL_ARGS_ASSERT_UTF8_HOP_SAFE;

    return utf8_hop_safe(s, off, start, end);
}

bool
Perl_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p)
{
    PERL_ARGS_ASSERT_UTF8_TO_UV;

    return utf8_to_uv(s, e, cp_p, advance_p);
}

bool
Perl_utf8_to_uv_errors(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors)
{
    PERL_ARGS_ASSERT_UTF8_TO_UV_ERRORS;

    return utf8_to_uv_errors(s, e, cp_p, advance_p, flags, errors);
}

bool
Perl_utf8_to_uv_flags(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags)
{
    PERL_ARGS_ASSERT_UTF8_TO_UV_FLAGS;

    return utf8_to_uv_flags(s, e, cp_p, advance_p, flags);
}

UV
Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags)
{
    PERL_ARGS_ASSERT_UTF8N_TO_UVCHR;

    return utf8n_to_uvchr(s, curlen, retlen, flags);
}

UV
Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors)
{
    PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_ERROR;

    return utf8n_to_uvchr_error(s, curlen, retlen, flags, errors);
}

U8 *
Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs)
{
    PERL_ARGS_ASSERT_UV_TO_UTF8_MSGS;

    return uv_to_utf8_msgs(d, uv, flags, msgs);
}

U8 *
Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv)
{
    PERL_ARGS_ASSERT_UVCHR_TO_UTF8;

    return uvchr_to_utf8(d, uv);
}

U8 *
Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
{
    PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS;

    return uvchr_to_utf8_flags(d, uv, flags);
}

U8 *
Perl_uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs)
{
    PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS_MSGS;

    return uvchr_to_utf8_flags_msgs(d, uv, flags, msgs);
}

U8 *
Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
{
    PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS;

    return uvoffuni_to_utf8_flags(d, uv, flags);
}

UV
Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
{
    PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR;

    return valid_utf8_to_uvchr(s, retlen);
}

I32
Perl_whichsig(pTHX_ const char *sig)
{
    PERL_ARGS_ASSERT_WHICHSIG;

    return whichsig(sig);
}


/* ex: set ro ft=c: */
