perl5.git.perl.org Git - perl5.git/blame_incremental

... / ...

Commit	Line	Data
	1	/* -- buffer-read-only: t --
	2	*
	3	* proto.h
	4	*
	5	* Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
	6	* 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others
	7	*
	8	* You may distribute under the terms of either the GNU General Public
	9	* License or the Artistic License, as specified in the README file.
	10	*
	11	* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
	12	* This file is built by regen/embed.pl from data in embed.fnc,
	13	* regen/embed.pl, regen/opcodes, intrpvar.h and perlvars.h.
	14	* Any changes made here will be lost!
	15	*
	16	* Edit those files and run 'make regen_headers' to effect changes.
	17	*/
	18
	19	START_EXTERN_C
	20	PERL_CALLCONV UV ASCII_TO_NEED(const UV enc, const UV ch)
	21	__attribute__deprecated__
	22	__attribute__warn_unused_result__
	23	__attribute__pure__;
	24
	25	PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing)
	26	__attribute__nonnull__(pTHX_1);
	27	#define PERL_ARGS_ASSERT_GV_AMUPDATE \
	28	assert(stash)
	29
	30	PERL_CALLCONV UV NATIVE_TO_NEED(const UV enc, const UV ch)
	31	__attribute__deprecated__
	32	__attribute__warn_unused_result__
	33	__attribute__pure__;
	34
	35	PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode);
	36	PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz)
	37	__attribute__malloc__
	38	__attribute__warn_unused_result__;
	39
	40	PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op)
	41	__attribute__nonnull__(pTHX_1);
	42	#define PERL_ARGS_ASSERT_SLAB_FREE \
	43	assert(op)
	44
	45	PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c)
	46	__attribute__warn_unused_result__;
	47
	48	PERL_CALLCONV bool Perl__is_uni_perl_idcont(pTHX_ UV c)
	49	__attribute__warn_unused_result__;
	50
	51	PERL_CALLCONV bool Perl__is_uni_perl_idstart(pTHX_ UV c)
	52	__attribute__warn_unused_result__;
	53
	54	PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p)
	55	__attribute__warn_unused_result__
	56	__attribute__nonnull__(pTHX_2);
	57	#define PERL_ARGS_ASSERT__IS_UTF8_FOO \
	58	assert(p)
	59
	60	PERL_CALLCONV bool Perl__is_utf8_mark(pTHX_ const U8 *p)
	61	__attribute__warn_unused_result__
	62	__attribute__nonnull__(pTHX_1);
	63	#define PERL_ARGS_ASSERT__IS_UTF8_MARK \
	64	assert(p)
	65
	66	PERL_CALLCONV bool Perl__is_utf8_perl_idcont(pTHX_ const U8 *p)
	67	__attribute__warn_unused_result__
	68	__attribute__nonnull__(pTHX_1);
	69	#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \
	70	assert(p)
	71
	72	PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p)
	73	__attribute__warn_unused_result__
	74	__attribute__nonnull__(pTHX_1);
	75	#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \
	76	assert(p)
	77
	78	PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 p, STRLEN lenp, const U8 flags)
	79	__attribute__nonnull__(pTHX_2)
	80	__attribute__nonnull__(pTHX_3);
	81	#define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \
	82	assert(p); assert(lenp)
	83
	84	PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 p, U8 ustrp, STRLEN lenp, U8 flags, bool tainted_ptr)
	85	__attribute__nonnull__(pTHX_1)
	86	__attribute__nonnull__(pTHX_2);
	87	#define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \
	88	assert(p); assert(ustrp)
	89
	90	PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 p, U8 ustrp, STRLEN lenp, const bool flags, bool tainted_ptr)
	91	__attribute__nonnull__(pTHX_1)
	92	__attribute__nonnull__(pTHX_2);
	93	#define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \
	94	assert(p); assert(ustrp)
	95
	96	PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 p, U8 ustrp, STRLEN lenp, const bool flags, bool tainted_ptr)
	97	__attribute__nonnull__(pTHX_1)
	98	__attribute__nonnull__(pTHX_2);
	99	#define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \
	100	assert(p); assert(ustrp)
	101
	102	PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 p, U8 ustrp, STRLEN lenp, const bool flags, bool tainted_ptr)
	103	__attribute__nonnull__(pTHX_1)
	104	__attribute__nonnull__(pTHX_2);
	105	#define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \
	106	assert(p); assert(ustrp)
	107
	108	PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags)
	109	__attribute__nonnull__(pTHX_1);
	110	#define PERL_ARGS_ASSERT_ALLOCMY \
	111	assert(name)
	112
	113	PERL_CALLCONV SV* Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int dir)
	114	__attribute__nonnull__(pTHX_1)
	115	__attribute__nonnull__(pTHX_2);
	116	#define PERL_ARGS_ASSERT_AMAGIC_CALL \
	117	assert(left); assert(right)
	118
	119	PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method)
	120	__attribute__nonnull__(pTHX_1);
	121	#define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \
	122	assert(ref)
	123
	124	PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method);
	125	PERL_STATIC_INLINE void S_append_utf8_from_native_byte(const U8 byte, U8** dest)
	126	__attribute__nonnull__(2);
	127	#define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \
	128	assert(dest)
	129
	130	PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV mark, SV sp)
	131	__attribute__nonnull__(pTHX_2)
	132	__attribute__nonnull__(pTHX_3);
	133	#define PERL_ARGS_ASSERT_APPLY \
	134	assert(mark); assert(sp)
	135
	136	PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char stashpv, CV cv, const char *attrstr, STRLEN len)
	137	__attribute__nonnull__(pTHX_1)
	138	__attribute__nonnull__(pTHX_2)
	139	__attribute__nonnull__(pTHX_3);
	140	#define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \
	141	assert(stashpv); assert(cv); assert(attrstr)
	142
	143	PERL_CALLCONV void Perl_atfork_lock(void);
	144	PERL_CALLCONV void Perl_atfork_unlock(void);
	145	PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av)
	146	__attribute__nonnull__(pTHX_1);
	147	#define PERL_ARGS_ASSERT_AV_ARYLEN_P \
	148	assert(av)
	149
	150	PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av)
	151	__attribute__nonnull__(pTHX_1);
	152	#define PERL_ARGS_ASSERT_AV_CLEAR \
	153	assert(av)
	154
	155	PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV *const avp, SV const val)
	156	__attribute__nonnull__(pTHX_1)
	157	__attribute__nonnull__(pTHX_2);
	158	#define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \
	159	assert(avp); assert(val)
	160
	161	PERL_CALLCONV SV Perl_av_create_and_unshift_one(pTHX_ AV const avp, SV *const val)
	162	__attribute__nonnull__(pTHX_1)
	163	__attribute__nonnull__(pTHX_2);
	164	#define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \
	165	assert(avp); assert(val)
	166
	167	PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)
	168	__attribute__nonnull__(pTHX_1);
	169	#define PERL_ARGS_ASSERT_AV_DELETE \
	170	assert(av)
	171
	172	PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key)
	173	__attribute__warn_unused_result__
	174	__attribute__nonnull__(pTHX_1);
	175	#define PERL_ARGS_ASSERT_AV_EXISTS \
	176	assert(av)
	177
	178	PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, SSize_t key)
	179	__attribute__nonnull__(pTHX_1);
	180	#define PERL_ARGS_ASSERT_AV_EXTEND \
	181	assert(av)
	182
	183	PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV av, SSize_t key, SSize_t maxp, SV *allocp, SV *arrayp)
	184	__attribute__nonnull__(pTHX_3)
	185	__attribute__nonnull__(pTHX_4)
	186	__attribute__nonnull__(pTHX_5);
	187	#define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \
	188	assert(maxp); assert(allocp); assert(arrayp)
	189
	190	PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
	191	__attribute__warn_unused_result__
	192	__attribute__nonnull__(pTHX_1);
	193	#define PERL_ARGS_ASSERT_AV_FETCH \
	194	assert(av)
	195
	196	PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill)
	197	__attribute__nonnull__(pTHX_1);
	198	#define PERL_ARGS_ASSERT_AV_FILL \
	199	assert(av)
	200
	201	PERL_CALLCONV IV* Perl_av_iter_p(pTHX_ AV *av)
	202	__attribute__nonnull__(pTHX_1);
	203	#define PERL_ARGS_ASSERT_AV_ITER_P \
	204	assert(av)
	205
	206	PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av)
	207	__attribute__warn_unused_result__
	208	__attribute__nonnull__(pTHX_1);
	209	#define PERL_ARGS_ASSERT_AV_LEN \
	210	assert(av)
	211
	212	PERL_CALLCONV AV* Perl_av_make(pTHX_ SSize_t size, SV **strp)
	213	__attribute__warn_unused_result__
	214	__attribute__nonnull__(pTHX_2);
	215	#define PERL_ARGS_ASSERT_AV_MAKE \
	216	assert(strp)
	217
	218	PERL_CALLCONV SV* Perl_av_pop(pTHX_ AV *av)
	219	__attribute__nonnull__(pTHX_1);
	220	#define PERL_ARGS_ASSERT_AV_POP \
	221	assert(av)
	222
	223	PERL_CALLCONV void Perl_av_push(pTHX_ AV av, SV val)
	224	__attribute__nonnull__(pTHX_1)
	225	__attribute__nonnull__(pTHX_2);
	226	#define PERL_ARGS_ASSERT_AV_PUSH \
	227	assert(av); assert(val)
	228
	229	PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av)
	230	__attribute__nonnull__(pTHX_1);
	231	#define PERL_ARGS_ASSERT_AV_REIFY \
	232	assert(av)
	233
	234	PERL_CALLCONV SV* Perl_av_shift(pTHX_ AV *av)
	235	__attribute__warn_unused_result__
	236	__attribute__nonnull__(pTHX_1);
	237	#define PERL_ARGS_ASSERT_AV_SHIFT \
	238	assert(av)
	239
	240	PERL_CALLCONV SV** Perl_av_store(pTHX_ AV av, SSize_t key, SV val)
	241	__attribute__nonnull__(pTHX_1);
	242	#define PERL_ARGS_ASSERT_AV_STORE \
	243	assert(av)
	244
	245	/* PERL_CALLCONV SSize_t Perl_av_tindex(pTHX_ AV *av)
	246	__attribute__warn_unused_result__
	247	__attribute__nonnull__(pTHX_1); */
	248
	249	PERL_STATIC_INLINE SSize_t S_av_top_index(pTHX_ AV *av)
	250	__attribute__warn_unused_result__
	251	__attribute__nonnull__(pTHX_1);
	252	#define PERL_ARGS_ASSERT_AV_TOP_INDEX \
	253	assert(av)
	254
	255	PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av)
	256	__attribute__nonnull__(pTHX_1);
	257	#define PERL_ARGS_ASSERT_AV_UNDEF \
	258	assert(av)
	259
	260	PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num)
	261	__attribute__nonnull__(pTHX_1);
	262	#define PERL_ARGS_ASSERT_AV_UNSHIFT \
	263	assert(av)
	264
	265	PERL_CALLCONV OP* Perl_bind_match(pTHX_ I32 type, OP left, OP right)
	266	__attribute__warn_unused_result__
	267	__attribute__nonnull__(pTHX_2)
	268	__attribute__nonnull__(pTHX_3);
	269	#define PERL_ARGS_ASSERT_BIND_MATCH \
	270	assert(left); assert(right)
	271
	272	PERL_CALLCONV OP* Perl_block_end(pTHX_ I32 floor, OP* seq)
	273	__attribute__warn_unused_result__;
	274
	275	PERL_CALLCONV I32 Perl_block_gimme(pTHX)
	276	__attribute__warn_unused_result__;
	277
	278	PERL_CALLCONV int Perl_block_start(pTHX_ int full)
	279	__attribute__warn_unused_result__;
	280
	281	PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk)
	282	__attribute__nonnull__(pTHX_1);
	283	#define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \
	284	assert(hk)
	285
	286	PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX);
	287	PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX);
	288	PERL_CALLCONV void Perl_boot_core_mro(pTHX);
	289	PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 b, STRLEN blen, const U8 u, STRLEN ulen)
	290	__attribute__nonnull__(pTHX_1)
	291	__attribute__nonnull__(pTHX_3);
	292	#define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \
	293	assert(b); assert(u)
	294
	295	PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 s, STRLEN len, bool *is_utf8)
	296	__attribute__nonnull__(pTHX_1)
	297	__attribute__nonnull__(pTHX_2);
	298	#define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \
	299	assert(s); assert(len)
	300
	301	PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 s, STRLEN len)
	302	__attribute__nonnull__(pTHX_1)
	303	__attribute__nonnull__(pTHX_2);
	304	#define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \
	305	assert(s); assert(len)
	306
	307	PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** argv)
	308	__attribute__nonnull__(pTHX_1)
	309	__attribute__nonnull__(pTHX_3);
	310	#define PERL_ARGS_ASSERT_CALL_ARGV \
	311	assert(sub_name); assert(argv)
	312
	313	PERL_CALLCONV void Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr);
	314	PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList)
	315	__attribute__nonnull__(pTHX_2);
	316	#define PERL_ARGS_ASSERT_CALL_LIST \
	317	assert(paramList)
	318
	319	PERL_CALLCONV I32 Perl_call_method(pTHX_ const char* methname, I32 flags)
	320	__attribute__nonnull__(pTHX_1);
	321	#define PERL_ARGS_ASSERT_CALL_METHOD \
	322	assert(methname)
	323
	324	PERL_CALLCONV I32 Perl_call_pv(pTHX_ const char* sub_name, I32 flags)
	325	__attribute__nonnull__(pTHX_1);
	326	#define PERL_ARGS_ASSERT_CALL_PV \
	327	assert(sub_name)
	328
	329	PERL_CALLCONV I32 Perl_call_sv(pTHX_ SV* sv, VOL I32 flags)
	330	__attribute__nonnull__(pTHX_1);
	331	#define PERL_ARGS_ASSERT_CALL_SV \
	332	assert(sv)
	333
	334	PERL_CALLCONV const PERL_CONTEXT * Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp);
	335	PERL_CALLCONV Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size)
	336	__attribute__malloc__
	337	__attribute__warn_unused_result__;
	338
	339	PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* statbufp)
	340	__attribute__warn_unused_result__
	341	__attribute__nonnull__(pTHX_3);
	342	#define PERL_ARGS_ASSERT_CANDO \
	343	assert(statbufp)
	344
	345	PERL_CALLCONV I32 Perl_cast_i32(pTHX_ NV f)
	346	__attribute__warn_unused_result__;
	347
	348	PERL_CALLCONV IV Perl_cast_iv(pTHX_ NV f)
	349	__attribute__warn_unused_result__;
	350
	351	PERL_CALLCONV U32 Perl_cast_ulong(pTHX_ NV f)
	352	__attribute__warn_unused_result__;
	353
	354	PERL_CALLCONV UV Perl_cast_uv(pTHX_ NV f)
	355	__attribute__warn_unused_result__;
	356
	357	PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len)
	358	__attribute__nonnull__(pTHX_1);
	359	#define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \
	360	assert(s)
	361
	362	PERL_CALLCONV OP * Perl_ck_anoncode(pTHX_ OP *o)
	363	__attribute__warn_unused_result__
	364	__attribute__nonnull__(pTHX_1);
	365	#define PERL_ARGS_ASSERT_CK_ANONCODE \
	366	assert(o)
	367
	368	PERL_CALLCONV OP * Perl_ck_backtick(pTHX_ OP *o)
	369	__attribute__warn_unused_result__
	370	__attribute__nonnull__(pTHX_1);
	371	#define PERL_ARGS_ASSERT_CK_BACKTICK \
	372	assert(o)
	373
	374	PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o)
	375	__attribute__warn_unused_result__
	376	__attribute__nonnull__(pTHX_1);
	377	#define PERL_ARGS_ASSERT_CK_BITOP \
	378	assert(o)
	379
	380	PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o)
	381	__attribute__warn_unused_result__
	382	__attribute__nonnull__(pTHX_1);
	383	#define PERL_ARGS_ASSERT_CK_CMP \
	384	assert(o)
	385
	386	PERL_CALLCONV OP * Perl_ck_concat(pTHX_ OP *o)
	387	__attribute__warn_unused_result__
	388	__attribute__nonnull__(pTHX_1);
	389	#define PERL_ARGS_ASSERT_CK_CONCAT \
	390	assert(o)
	391
	392	PERL_CALLCONV OP * Perl_ck_defined(pTHX_ OP *o)
	393	__attribute__warn_unused_result__
	394	__attribute__nonnull__(pTHX_1);
	395	#define PERL_ARGS_ASSERT_CK_DEFINED \
	396	assert(o)
	397
	398	PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o)
	399	__attribute__warn_unused_result__
	400	__attribute__nonnull__(pTHX_1);
	401	#define PERL_ARGS_ASSERT_CK_DELETE \
	402	assert(o)
	403
	404	PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o)
	405	__attribute__warn_unused_result__
	406	__attribute__nonnull__(pTHX_1);
	407	#define PERL_ARGS_ASSERT_CK_EACH \
	408	assert(o)
	409
	410	PERL_CALLCONV OP* Perl_ck_entersub_args_core(pTHX_ OP entersubop, GV namegv, SV *protosv)
	411	__attribute__nonnull__(pTHX_1)
	412	__attribute__nonnull__(pTHX_2)
	413	__attribute__nonnull__(pTHX_3);
	414	#define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \
	415	assert(entersubop); assert(namegv); assert(protosv)
	416
	417	PERL_CALLCONV OP* Perl_ck_entersub_args_list(pTHX_ OP *entersubop)
	418	__attribute__nonnull__(pTHX_1);
	419	#define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \
	420	assert(entersubop)
	421
	422	PERL_CALLCONV OP* Perl_ck_entersub_args_proto(pTHX_ OP entersubop, GV namegv, SV *protosv)
	423	__attribute__nonnull__(pTHX_1)
	424	__attribute__nonnull__(pTHX_2)
	425	__attribute__nonnull__(pTHX_3);
	426	#define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \
	427	assert(entersubop); assert(namegv); assert(protosv)
	428
	429	PERL_CALLCONV OP* Perl_ck_entersub_args_proto_or_list(pTHX_ OP entersubop, GV namegv, SV *protosv)
	430	__attribute__nonnull__(pTHX_1)
	431	__attribute__nonnull__(pTHX_2)
	432	__attribute__nonnull__(pTHX_3);
	433	#define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \
	434	assert(entersubop); assert(namegv); assert(protosv)
	435
	436	PERL_CALLCONV OP * Perl_ck_eof(pTHX_ OP *o)
	437	__attribute__warn_unused_result__
	438	__attribute__nonnull__(pTHX_1);
	439	#define PERL_ARGS_ASSERT_CK_EOF \
	440	assert(o)
	441
	442	PERL_CALLCONV OP * Perl_ck_eval(pTHX_ OP *o)
	443	__attribute__warn_unused_result__
	444	__attribute__nonnull__(pTHX_1);
	445	#define PERL_ARGS_ASSERT_CK_EVAL \
	446	assert(o)
	447
	448	PERL_CALLCONV OP * Perl_ck_exec(pTHX_ OP *o)
	449	__attribute__warn_unused_result__
	450	__attribute__nonnull__(pTHX_1);
	451	#define PERL_ARGS_ASSERT_CK_EXEC \
	452	assert(o)
	453
	454	PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o)
	455	__attribute__warn_unused_result__
	456	__attribute__nonnull__(pTHX_1);
	457	#define PERL_ARGS_ASSERT_CK_EXISTS \
	458	assert(o)
	459
	460	PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o)
	461	__attribute__warn_unused_result__
	462	__attribute__nonnull__(pTHX_1);
	463	#define PERL_ARGS_ASSERT_CK_FTST \
	464	assert(o)
	465
	466	PERL_CALLCONV OP * Perl_ck_fun(pTHX_ OP *o)
	467	__attribute__warn_unused_result__
	468	__attribute__nonnull__(pTHX_1);
	469	#define PERL_ARGS_ASSERT_CK_FUN \
	470	assert(o)
	471
	472	PERL_CALLCONV OP * Perl_ck_glob(pTHX_ OP *o)
	473	__attribute__warn_unused_result__
	474	__attribute__nonnull__(pTHX_1);
	475	#define PERL_ARGS_ASSERT_CK_GLOB \
	476	assert(o)
	477
	478	PERL_CALLCONV OP * Perl_ck_grep(pTHX_ OP *o)
	479	__attribute__warn_unused_result__
	480	__attribute__nonnull__(pTHX_1);
	481	#define PERL_ARGS_ASSERT_CK_GREP \
	482	assert(o)
	483
	484	PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o)
	485	__attribute__warn_unused_result__
	486	__attribute__nonnull__(pTHX_1);
	487	#define PERL_ARGS_ASSERT_CK_INDEX \
	488	assert(o)
	489
	490	PERL_CALLCONV OP * Perl_ck_join(pTHX_ OP *o)
	491	__attribute__warn_unused_result__
	492	__attribute__nonnull__(pTHX_1);
	493	#define PERL_ARGS_ASSERT_CK_JOIN \
	494	assert(o)
	495
	496	PERL_CALLCONV OP * Perl_ck_length(pTHX_ OP *o)
	497	__attribute__warn_unused_result__
	498	__attribute__nonnull__(pTHX_1);
	499	#define PERL_ARGS_ASSERT_CK_LENGTH \
	500	assert(o)
	501
	502	PERL_CALLCONV OP * Perl_ck_lfun(pTHX_ OP *o)
	503	__attribute__warn_unused_result__
	504	__attribute__nonnull__(pTHX_1);
	505	#define PERL_ARGS_ASSERT_CK_LFUN \
	506	assert(o)
	507
	508	PERL_CALLCONV OP * Perl_ck_listiob(pTHX_ OP *o)
	509	__attribute__warn_unused_result__
	510	__attribute__nonnull__(pTHX_1);
	511	#define PERL_ARGS_ASSERT_CK_LISTIOB \
	512	assert(o)
	513
	514	PERL_CALLCONV OP * Perl_ck_match(pTHX_ OP *o)
	515	__attribute__warn_unused_result__
	516	__attribute__nonnull__(pTHX_1);
	517	#define PERL_ARGS_ASSERT_CK_MATCH \
	518	assert(o)
	519
	520	PERL_CALLCONV OP * Perl_ck_method(pTHX_ OP *o)
	521	__attribute__warn_unused_result__
	522	__attribute__nonnull__(pTHX_1);
	523	#define PERL_ARGS_ASSERT_CK_METHOD \
	524	assert(o)
	525
	526	PERL_CALLCONV OP * Perl_ck_null(pTHX_ OP *o)
	527	__attribute__warn_unused_result__
	528	__attribute__nonnull__(pTHX_1);
	529	#define PERL_ARGS_ASSERT_CK_NULL \
	530	assert(o)
	531
	532	PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o)
	533	__attribute__warn_unused_result__
	534	__attribute__nonnull__(pTHX_1);
	535	#define PERL_ARGS_ASSERT_CK_OPEN \
	536	assert(o)
	537
	538	PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o)
	539	__attribute__warn_unused_result__
	540	__attribute__nonnull__(pTHX_1);
	541	#define PERL_ARGS_ASSERT_CK_READLINE \
	542	assert(o)
	543
	544	PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o)
	545	__attribute__warn_unused_result__
	546	__attribute__nonnull__(pTHX_1);
	547	#define PERL_ARGS_ASSERT_CK_REPEAT \
	548	assert(o)
	549
	550	PERL_CALLCONV OP * Perl_ck_require(pTHX_ OP *o)
	551	__attribute__warn_unused_result__
	552	__attribute__nonnull__(pTHX_1);
	553	#define PERL_ARGS_ASSERT_CK_REQUIRE \
	554	assert(o)
	555
	556	PERL_CALLCONV OP * Perl_ck_return(pTHX_ OP *o)
	557	__attribute__warn_unused_result__
	558	__attribute__nonnull__(pTHX_1);
	559	#define PERL_ARGS_ASSERT_CK_RETURN \
	560	assert(o)
	561
	562	PERL_CALLCONV OP * Perl_ck_rfun(pTHX_ OP *o)
	563	__attribute__warn_unused_result__
	564	__attribute__nonnull__(pTHX_1);
	565	#define PERL_ARGS_ASSERT_CK_RFUN \
	566	assert(o)
	567
	568	PERL_CALLCONV OP * Perl_ck_rvconst(pTHX_ OP *o)
	569	__attribute__warn_unused_result__
	570	__attribute__nonnull__(pTHX_1);
	571	#define PERL_ARGS_ASSERT_CK_RVCONST \
	572	assert(o)
	573
	574	PERL_CALLCONV OP * Perl_ck_sassign(pTHX_ OP *o)
	575	__attribute__warn_unused_result__
	576	__attribute__nonnull__(pTHX_1);
	577	#define PERL_ARGS_ASSERT_CK_SASSIGN \
	578	assert(o)
	579
	580	PERL_CALLCONV OP * Perl_ck_select(pTHX_ OP *o)
	581	__attribute__warn_unused_result__
	582	__attribute__nonnull__(pTHX_1);
	583	#define PERL_ARGS_ASSERT_CK_SELECT \
	584	assert(o)
	585
	586	PERL_CALLCONV OP * Perl_ck_shift(pTHX_ OP *o)
	587	__attribute__warn_unused_result__
	588	__attribute__nonnull__(pTHX_1);
	589	#define PERL_ARGS_ASSERT_CK_SHIFT \
	590	assert(o)
	591
	592	PERL_CALLCONV OP * Perl_ck_smartmatch(pTHX_ OP *o)
	593	__attribute__warn_unused_result__
	594	__attribute__nonnull__(pTHX_1);
	595	#define PERL_ARGS_ASSERT_CK_SMARTMATCH \
	596	assert(o)
	597
	598	PERL_CALLCONV OP * Perl_ck_sort(pTHX_ OP *o)
	599	__attribute__warn_unused_result__
	600	__attribute__nonnull__(pTHX_1);
	601	#define PERL_ARGS_ASSERT_CK_SORT \
	602	assert(o)
	603
	604	PERL_CALLCONV OP * Perl_ck_spair(pTHX_ OP *o)
	605	__attribute__warn_unused_result__
	606	__attribute__nonnull__(pTHX_1);
	607	#define PERL_ARGS_ASSERT_CK_SPAIR \
	608	assert(o)
	609
	610	PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o)
	611	__attribute__warn_unused_result__
	612	__attribute__nonnull__(pTHX_1);
	613	#define PERL_ARGS_ASSERT_CK_SPLIT \
	614	assert(o)
	615
	616	PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o)
	617	__attribute__warn_unused_result__
	618	__attribute__nonnull__(pTHX_1);
	619	#define PERL_ARGS_ASSERT_CK_SUBR \
	620	assert(o)
	621
	622	PERL_CALLCONV OP * Perl_ck_substr(pTHX_ OP *o)
	623	__attribute__warn_unused_result__
	624	__attribute__nonnull__(pTHX_1);
	625	#define PERL_ARGS_ASSERT_CK_SUBSTR \
	626	assert(o)
	627
	628	PERL_CALLCONV OP * Perl_ck_svconst(pTHX_ OP *o)
	629	__attribute__warn_unused_result__
	630	__attribute__nonnull__(pTHX_1);
	631	#define PERL_ARGS_ASSERT_CK_SVCONST \
	632	assert(o)
	633
	634	PERL_CALLCONV OP * Perl_ck_tell(pTHX_ OP *o)
	635	__attribute__warn_unused_result__
	636	__attribute__nonnull__(pTHX_1);
	637	#define PERL_ARGS_ASSERT_CK_TELL \
	638	assert(o)
	639
	640	PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o)
	641	__attribute__warn_unused_result__
	642	__attribute__nonnull__(pTHX_1);
	643	#define PERL_ARGS_ASSERT_CK_TRUNC \
	644	assert(o)
	645
	646	PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char* pat, ...)
	647	__attribute__format__(__printf__,pTHX_2,pTHX_3)
	648	__attribute__nonnull__(pTHX_2);
	649	#define PERL_ARGS_ASSERT_CK_WARNER \
	650	assert(pat)
	651
	652	PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...)
	653	__attribute__format__(__printf__,pTHX_2,pTHX_3)
	654	__attribute__nonnull__(pTHX_2);
	655	#define PERL_ARGS_ASSERT_CK_WARNER_D \
	656	assert(pat)
	657
	658	PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w);
	659	PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w);
	660	PERL_CALLCONV const COP* Perl_closest_cop(pTHX_ const COP cop, const OP o, const OP *curop, bool opnext)
	661	__attribute__nonnull__(pTHX_1);
	662	#define PERL_ARGS_ASSERT_CLOSEST_COP \
	663	assert(cop)
	664
	665	PERL_CALLCONV OP* Perl_convert(pTHX_ I32 optype, I32 flags, OP* o)
	666	__attribute__warn_unused_result__;
	667
	668	PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP const cop, STRLEN len, U32 *flags)
	669	__attribute__nonnull__(pTHX_1);
	670	#define PERL_ARGS_ASSERT_COP_FETCH_LABEL \
	671	assert(cop)
	672
	673	PERL_CALLCONV void Perl_cop_store_label(pTHX_ COP const cop, const char label, STRLEN len, U32 flags)
	674	__attribute__nonnull__(pTHX_1)
	675	__attribute__nonnull__(pTHX_2);
	676	#define PERL_ARGS_ASSERT_COP_STORE_LABEL \
	677	assert(cop); assert(label)
	678
	679	PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV sv, const char name, const int code, int * const opnum)
	680	__attribute__nonnull__(pTHX_2);
	681	#define PERL_ARGS_ASSERT_CORE_PROTOTYPE \
	682	assert(name)
	683
	684	PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, const int opnum)
	685	__attribute__nonnull__(pTHX_1);
	686	#define PERL_ARGS_ASSERT_CORESUB_OP \
	687	assert(coreargssv)
	688
	689	PERL_CALLCONV PERL_CONTEXT* Perl_create_eval_scope(pTHX_ U32 flags);
	690	PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char* pat, ...)
	691	__attribute__noreturn__
	692	__attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
	693
	694	PERL_STATIC_NO_RET void S_croak_memory_wrap(void)
	695	__attribute__noreturn__;
	696
	697	PERL_CALLCONV_NO_RET void Perl_croak_no_mem(void)
	698	__attribute__noreturn__;
	699
	700	PERL_CALLCONV_NO_RET void Perl_croak_no_modify(void)
	701	__attribute__noreturn__;
	702
	703	PERL_CALLCONV_NO_RET void Perl_croak_popstack(void)
	704	__attribute__noreturn__;
	705
	706	PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex)
	707	__attribute__noreturn__
	708	__attribute__nonnull__(pTHX_1);
	709	#define PERL_ARGS_ASSERT_CROAK_SV \
	710	assert(baseex)
	711
	712	PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV const cv, const char const params)
	713	__attribute__noreturn__
	714	__attribute__nonnull__(1)
	715	__attribute__nonnull__(2);
	716	#define PERL_ARGS_ASSERT_CROAK_XS_USAGE \
	717	assert(cv); assert(params)
	718
	719	PERL_CALLCONV regexp_engine const * Perl_current_re_engine(pTHX);
	720	PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o)
	721	__attribute__warn_unused_result__
	722	__attribute__nonnull__(pTHX_1);
	723	#define PERL_ARGS_ASSERT_CUSTOM_OP_DESC \
	724	assert(o)
	725
	726	PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field)
	727	__attribute__warn_unused_result__
	728	__attribute__nonnull__(pTHX_1);
	729	#define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \
	730	assert(o)
	731
	732	PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o)
	733	__attribute__warn_unused_result__
	734	__attribute__nonnull__(pTHX_1);
	735	#define PERL_ARGS_ASSERT_CUSTOM_OP_NAME \
	736	assert(o)
	737
	738	PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop)
	739	__attribute__nonnull__(pTHX_1)
	740	__attribute__nonnull__(pTHX_2);
	741	#define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \
	742	assert(ppaddr); assert(xop)
	743
	744	/* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o)
	745	__attribute__pure__
	746	__attribute__nonnull__(pTHX_1); */
	747
	748	PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags)
	749	__attribute__nonnull__(pTHX_1);
	750	#define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \
	751	assert(cv)
	752
	753	PERL_CALLCONV CV* Perl_cv_clone(pTHX_ CV* proto)
	754	__attribute__nonnull__(pTHX_1);
	755	#define PERL_ARGS_ASSERT_CV_CLONE \
	756	assert(proto)
	757
	758	PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target)
	759	__attribute__nonnull__(pTHX_1)
	760	__attribute__nonnull__(pTHX_2);
	761	#define PERL_ARGS_ASSERT_CV_CLONE_INTO \
	762	assert(proto); assert(target)
	763
	764	PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv)
	765	__attribute__warn_unused_result__;
	766
	767	PERL_CALLCONV SV* Perl_cv_const_sv_or_av(pTHX_ const CV *const cv)
	768	__attribute__warn_unused_result__;
	769
	770	PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv)
	771	__attribute__nonnull__(pTHX_1);
	772	#define PERL_ARGS_ASSERT_CV_FORGET_SLAB \
	773	assert(cv)
	774
	775	PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV cv, Perl_call_checker ckfun_p, SV **ckobj_p)
	776	__attribute__nonnull__(pTHX_1)
	777	__attribute__nonnull__(pTHX_2)
	778	__attribute__nonnull__(pTHX_3);
	779	#define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \
	780	assert(cv); assert(ckfun_p); assert(ckobj_p)
	781
	782	PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV cv, Perl_call_checker ckfun, SV ckobj)
	783	__attribute__nonnull__(pTHX_1)
	784	__attribute__nonnull__(pTHX_2)
	785	__attribute__nonnull__(pTHX_3);
	786	#define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \
	787	assert(cv); assert(ckfun); assert(ckobj)
	788
	789	PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv)
	790	__attribute__nonnull__(pTHX_1);
	791	#define PERL_ARGS_ASSERT_CV_UNDEF \
	792	assert(cv)
	793
	794	PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv)
	795	__attribute__nonnull__(pTHX_1);
	796	#define PERL_ARGS_ASSERT_CVGV_SET \
	797	assert(cv)
	798
	799	PERL_CALLCONV void Perl_cvstash_set(pTHX_ CV* cv, HV* stash)
	800	__attribute__nonnull__(pTHX_1);
	801	#define PERL_ARGS_ASSERT_CVSTASH_SET \
	802	assert(cv)
	803
	804	PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT* cx)
	805	__attribute__nonnull__(pTHX_1);
	806	#define PERL_ARGS_ASSERT_CX_DUMP \
	807	assert(cx)
	808
	809	PERL_CALLCONV I32 Perl_cxinc(pTHX)
	810	__attribute__warn_unused_result__;
	811
	812	PERL_CALLCONV void Perl_deb(pTHX_ const char* pat, ...)
	813	__attribute__format__(__printf__,pTHX_1,pTHX_2)
	814	__attribute__nonnull__(pTHX_1);
	815	#define PERL_ARGS_ASSERT_DEB \
	816	assert(pat)
	817
	818	PERL_CALLCONV void Perl_deb_stack_all(pTHX);
	819	PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o)
	820	__attribute__nonnull__(pTHX_1);
	821	#define PERL_ARGS_ASSERT_DEBOP \
	822	assert(o)
	823
	824	PERL_CALLCONV void Perl_debprofdump(pTHX);
	825	PERL_CALLCONV I32 Perl_debstack(pTHX);
	826	PERL_CALLCONV I32 Perl_debstackptrs(pTHX);
	827	PERL_CALLCONV SV * Perl_defelem_target(pTHX_ SV sv, MAGIC mg)
	828	__attribute__warn_unused_result__
	829	__attribute__nonnull__(pTHX_1);
	830	#define PERL_ARGS_ASSERT_DEFELEM_TARGET \
	831	assert(sv)
	832
	833	PERL_CALLCONV void Perl_delete_eval_scope(pTHX);
	834	PERL_CALLCONV char* Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen)
	835	__attribute__nonnull__(1)
	836	__attribute__nonnull__(2)
	837	__attribute__nonnull__(3)
	838	__attribute__nonnull__(4)
	839	__attribute__nonnull__(6);
	840	#define PERL_ARGS_ASSERT_DELIMCPY \
	841	assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
	842
	843	PERL_CALLCONV void Perl_despatch_signals(pTHX);
	844	PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...)
	845	__attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
	846
	847	PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex)
	848	__attribute__nonnull__(pTHX_1);
	849	#define PERL_ARGS_ASSERT_DIE_SV \
	850	assert(baseex)
	851
	852	PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV* msv)
	853	__attribute__noreturn__
	854	__attribute__nonnull__(pTHX_1);
	855	#define PERL_ARGS_ASSERT_DIE_UNWIND \
	856	assert(msv)
	857
	858	/* PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV* really, SV mark, SV sp)
	859	__attribute__nonnull__(pTHX_2)
	860	__attribute__nonnull__(pTHX_3); */
	861	#define PERL_ARGS_ASSERT_DO_AEXEC \
	862	assert(mark); assert(sp)
	863
	864	PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV* really, SV mark, SV sp, int fd, int do_report)
	865	__attribute__nonnull__(pTHX_2)
	866	__attribute__nonnull__(pTHX_3);
	867	#define PERL_ARGS_ASSERT_DO_AEXEC5 \
	868	assert(mark); assert(sp)
	869
	870	PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
	871	__attribute__nonnull__(pTHX_1);
	872	#define PERL_ARGS_ASSERT_DO_BINMODE \
	873	assert(fp)
	874
	875	PERL_CALLCONV bool Perl_do_close(pTHX_ GV* gv, bool not_implicit);
	876	PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO file, PADLIST padlist, int full)
	877	__attribute__nonnull__(pTHX_2);
	878	#define PERL_ARGS_ASSERT_DO_DUMP_PAD \
	879	assert(file)
	880
	881	PERL_CALLCONV bool Perl_do_eof(pTHX_ GV* gv)
	882	__attribute__nonnull__(pTHX_1);
	883	#define PERL_ARGS_ASSERT_DO_EOF \
	884	assert(gv)
	885
	886	PERL_CALLCONV void Perl_do_execfree(pTHX);
	887	PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO file, const char name, GV *sv)
	888	__attribute__nonnull__(pTHX_2)
	889	__attribute__nonnull__(pTHX_3);
	890	#define PERL_ARGS_ASSERT_DO_GV_DUMP \
	891	assert(file); assert(name)
	892
	893	PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO file, const char name, GV *sv)
	894	__attribute__nonnull__(pTHX_2)
	895	__attribute__nonnull__(pTHX_3);
	896	#define PERL_ARGS_ASSERT_DO_GVGV_DUMP \
	897	assert(file); assert(name)
	898
	899	PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO file, const char name, HV *sv)
	900	__attribute__nonnull__(pTHX_2)
	901	__attribute__nonnull__(pTHX_3);
	902	#define PERL_ARGS_ASSERT_DO_HV_DUMP \
	903	assert(file); assert(name)
	904
	905	PERL_CALLCONV void Perl_do_join(pTHX_ SV sv, SV delim, SV mark, SV sp)
	906	__attribute__nonnull__(pTHX_1)
	907	__attribute__nonnull__(pTHX_2)
	908	__attribute__nonnull__(pTHX_3)
	909	__attribute__nonnull__(pTHX_4);
	910	#define PERL_ARGS_ASSERT_DO_JOIN \
	911	assert(sv); assert(delim); assert(mark); assert(sp)
	912
	913	PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO file, const MAGIC mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
	914	__attribute__nonnull__(pTHX_2)
	915	__attribute__nonnull__(pTHX_3);
	916	#define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \
	917	assert(file); assert(mg)
	918
	919	PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV const left, SV const right)
	920	__attribute__warn_unused_result__
	921	__attribute__nonnull__(pTHX_1)
	922	__attribute__nonnull__(pTHX_2);
	923	#define PERL_ARGS_ASSERT_DO_NCMP \
	924	assert(left); assert(right)
	925
	926	PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO file, const OP o)
	927	__attribute__nonnull__(pTHX_2);
	928	#define PERL_ARGS_ASSERT_DO_OP_DUMP \
	929	assert(file)
	930
	931	/* PERL_CALLCONV bool Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp)
	932	__attribute__nonnull__(pTHX_1)
	933	__attribute__nonnull__(pTHX_2); */
	934	#define PERL_ARGS_ASSERT_DO_OPEN \
	935	assert(gv); assert(name)
	936
	937	PERL_CALLCONV bool Perl_do_open9(pTHX_ GV gv, const char name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO supplied_fp, SV svs, I32 num)
	938	__attribute__nonnull__(pTHX_1)
	939	__attribute__nonnull__(pTHX_2)
	940	__attribute__nonnull__(pTHX_8);
	941	#define PERL_ARGS_ASSERT_DO_OPEN9 \
	942	assert(gv); assert(name); assert(svs)
	943
	944	PERL_CALLCONV bool Perl_do_openn(pTHX_ GV gv, const char oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO supplied_fp, SV *svp, I32 num)
	945	__attribute__nonnull__(pTHX_1)
	946	__attribute__nonnull__(pTHX_2);
	947	#define PERL_ARGS_ASSERT_DO_OPENN \
	948	assert(gv); assert(oname)
	949
	950	PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO file, const PMOP pm)
	951	__attribute__nonnull__(pTHX_2);
	952	#define PERL_ARGS_ASSERT_DO_PMOP_DUMP \
	953	assert(file)
	954
	955	PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp)
	956	__attribute__nonnull__(pTHX_2);
	957	#define PERL_ARGS_ASSERT_DO_PRINT \
	958	assert(fp)
	959
	960	PERL_CALLCONV OP* Perl_do_readline(pTHX)
	961	__attribute__warn_unused_result__;
	962
	963	PERL_CALLCONV bool Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence);
	964	PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, I32 len, SV** sarg)
	965	__attribute__nonnull__(pTHX_1)
	966	__attribute__nonnull__(pTHX_3);
	967	#define PERL_ARGS_ASSERT_DO_SPRINTF \
	968	assert(sv); assert(sarg)
	969
	970	PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO file, SV sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
	971	__attribute__nonnull__(pTHX_2);
	972	#define PERL_ARGS_ASSERT_DO_SV_DUMP \
	973	assert(file)
	974
	975	PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV* gv, Off_t pos, int whence)
	976	__attribute__nonnull__(pTHX_1);
	977	#define PERL_ARGS_ASSERT_DO_SYSSEEK \
	978	assert(gv)
	979
	980	PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV* gv)
	981	__attribute__warn_unused_result__
	982	__attribute__nonnull__(pTHX_1);
	983	#define PERL_ARGS_ASSERT_DO_TELL \
	984	assert(gv)
	985
	986	PERL_CALLCONV I32 Perl_do_trans(pTHX_ SV* sv)
	987	__attribute__nonnull__(pTHX_1);
	988	#define PERL_ARGS_ASSERT_DO_TRANS \
	989	assert(sv)
	990
	991	PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, SSize_t offset, int size)
	992	__attribute__nonnull__(pTHX_1);
	993	#define PERL_ARGS_ASSERT_DO_VECGET \
	994	assert(sv)
	995
	996	PERL_CALLCONV void Perl_do_vecset(pTHX_ SV* sv)
	997	__attribute__nonnull__(pTHX_1);
	998	#define PERL_ARGS_ASSERT_DO_VECSET \
	999	assert(sv)
	1000
	1001	PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV* sv, SV* left, SV* right)
	1002	__attribute__nonnull__(pTHX_2)
	1003	__attribute__nonnull__(pTHX_3)
	1004	__attribute__nonnull__(pTHX_4);
	1005	#define PERL_ARGS_ASSERT_DO_VOP \
	1006	assert(sv); assert(left); assert(right)
	1007
	1008	PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin)
	1009	__attribute__nonnull__(pTHX_1);
	1010	#define PERL_ARGS_ASSERT_DOFILE \
	1011	assert(term)
	1012
	1013	PERL_CALLCONV bool Perl_doing_taint(int argc, char argv, char env)
	1014	__attribute__warn_unused_result__;
	1015
	1016	PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
	1017	__attribute__nonnull__(pTHX_1);
	1018	#define PERL_ARGS_ASSERT_DOREF \
	1019	assert(o)
	1020
	1021	PERL_CALLCONV void Perl_dounwind(pTHX_ I32 cxix);
	1022	PERL_CALLCONV I32 Perl_dowantarray(pTHX)
	1023	__attribute__warn_unused_result__;
	1024
	1025	PERL_CALLCONV void Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed)
	1026	__attribute__nonnull__(1);
	1027	#define PERL_ARGS_ASSERT_DRAND48_INIT_R \
	1028	assert(random_state)
	1029
	1030	PERL_CALLCONV double Perl_drand48_r(perl_drand48_t *random_state)
	1031	__attribute__nonnull__(1);
	1032	#define PERL_ARGS_ASSERT_DRAND48_R \
	1033	assert(random_state)
	1034
	1035	PERL_CALLCONV void Perl_dump_all(pTHX);
	1036	PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl);
	1037	PERL_CALLCONV void Perl_dump_eval(pTHX);
	1038	PERL_CALLCONV void Perl_dump_form(pTHX_ const GV* gv)
	1039	__attribute__nonnull__(pTHX_1);
	1040	#define PERL_ARGS_ASSERT_DUMP_FORM \
	1041	assert(gv)
	1042
	1043	PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO file, const char pat, ...)
	1044	__attribute__format__(__printf__,pTHX_3,pTHX_4)
	1045	__attribute__nonnull__(pTHX_2)
	1046	__attribute__nonnull__(pTHX_3);
	1047	#define PERL_ARGS_ASSERT_DUMP_INDENT \
	1048	assert(file); assert(pat)
	1049
	1050	PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV* stash)
	1051	__attribute__nonnull__(pTHX_1);
	1052	#define PERL_ARGS_ASSERT_DUMP_PACKSUBS \
	1053	assert(stash)
	1054
	1055	PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV* stash, bool justperl)
	1056	__attribute__nonnull__(pTHX_1);
	1057	#define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \
	1058	assert(stash)
	1059
	1060	PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV* gv)
	1061	__attribute__nonnull__(pTHX_1);
	1062	#define PERL_ARGS_ASSERT_DUMP_SUB \
	1063	assert(gv)
	1064
	1065	PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl)
	1066	__attribute__nonnull__(pTHX_1);
	1067	#define PERL_ARGS_ASSERT_DUMP_SUB_PERL \
	1068	assert(gv)
	1069
	1070	PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO file, const char pat, va_list *args)
	1071	__attribute__nonnull__(pTHX_2)
	1072	__attribute__nonnull__(pTHX_3);
	1073	#define PERL_ARGS_ASSERT_DUMP_VINDENT \
	1074	assert(file); assert(pat)
	1075
	1076	PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP const c, SV const sv)
	1077	__attribute__nonnull__(pTHX_1)
	1078	__attribute__nonnull__(pTHX_2);
	1079	#define PERL_ARGS_ASSERT_EMULATE_COP_IO \
	1080	assert(c); assert(sv)
	1081
	1082	PERL_CALLCONV SV* Perl_eval_pv(pTHX_ const char* p, I32 croak_on_error)
	1083	__attribute__nonnull__(pTHX_1);
	1084	#define PERL_ARGS_ASSERT_EVAL_PV \
	1085	assert(p)
	1086
	1087	PERL_CALLCONV I32 Perl_eval_sv(pTHX_ SV* sv, I32 flags)
	1088	__attribute__nonnull__(pTHX_1);
	1089	#define PERL_ARGS_ASSERT_EVAL_SV \
	1090	assert(sv)
	1091
	1092	PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV* sv, U32 flags)
	1093	__attribute__nonnull__(pTHX_1);
	1094	#define PERL_ARGS_ASSERT_FBM_COMPILE \
	1095	assert(sv)
	1096
	1097	PERL_CALLCONV char* Perl_fbm_instr(pTHX_ unsigned char* big, unsigned char* bigend, SV* littlestr, U32 flags)
	1098	__attribute__warn_unused_result__
	1099	__attribute__nonnull__(pTHX_1)
	1100	__attribute__nonnull__(pTHX_2)
	1101	__attribute__nonnull__(pTHX_3);
	1102	#define PERL_ARGS_ASSERT_FBM_INSTR \
	1103	assert(big); assert(bigend); assert(littlestr)
	1104
	1105	PERL_CALLCONV bool Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen)
	1106	__attribute__nonnull__(pTHX_1);
	1107	#define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED \
	1108	assert(name)
	1109
	1110	PERL_CALLCONV SV* Perl_filter_add(pTHX_ filter_t funcp, SV* datasv);
	1111	PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp)
	1112	__attribute__nonnull__(pTHX_1);
	1113	#define PERL_ARGS_ASSERT_FILTER_DEL \
	1114	assert(funcp)
	1115
	1116	PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen)
	1117	__attribute__warn_unused_result__
	1118	__attribute__nonnull__(pTHX_2);
	1119	#define PERL_ARGS_ASSERT_FILTER_READ \
	1120	assert(buf_sv)
	1121
	1122	PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP* o)
	1123	__attribute__nonnull__(pTHX_1);
	1124	#define PERL_ARGS_ASSERT_FINALIZE_OPTREE \
	1125	assert(o)
	1126
	1127	PERL_CALLCONV CV * Perl_find_lexical_cv(pTHX_ PADOFFSET off);
	1128	PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp)
	1129	__attribute__warn_unused_result__;
	1130
	1131	PERL_CALLCONV CV* Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp)
	1132	__attribute__warn_unused_result__;
	1133
	1134	PERL_CALLCONV SV* Perl_find_rundefsv(pTHX);
	1135	PERL_CALLCONV SV* Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq)
	1136	__attribute__nonnull__(pTHX_1);
	1137	#define PERL_ARGS_ASSERT_FIND_RUNDEFSV2 \
	1138	assert(cv)
	1139
	1140	PERL_CALLCONV PADOFFSET Perl_find_rundefsvoffset(pTHX)
	1141	__attribute__deprecated__;
	1142
	1143	PERL_CALLCONV char* Perl_find_script(pTHX_ const char scriptname, bool dosearch, const char const *const search_ext, I32 flags)
	1144	__attribute__nonnull__(pTHX_1);
	1145	#define PERL_ARGS_ASSERT_FIND_SCRIPT \
	1146	assert(scriptname)
	1147
	1148	PERL_CALLCONV I32 Perl_foldEQ(const char* a, const char* b, I32 len)
	1149	__attribute__pure__
	1150	__attribute__nonnull__(1)
	1151	__attribute__nonnull__(2);
	1152	#define PERL_ARGS_ASSERT_FOLDEQ \
	1153	assert(a); assert(b)
	1154
	1155	PERL_CALLCONV I32 Perl_foldEQ_latin1(const char* a, const char* b, I32 len)
	1156	__attribute__pure__
	1157	__attribute__nonnull__(1)
	1158	__attribute__nonnull__(2);
	1159	#define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \
	1160	assert(a); assert(b)
	1161
	1162	PERL_CALLCONV I32 Perl_foldEQ_locale(const char* a, const char* b, I32 len)
	1163	__attribute__pure__
	1164	__attribute__nonnull__(1)
	1165	__attribute__nonnull__(2);
	1166	#define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \
	1167	assert(a); assert(b)
	1168
	1169	/* PERL_CALLCONV I32 foldEQ_utf8(pTHX_ const char s1, char pe1, UV l1, bool u1, const char s2, char **pe2, UV l2, bool u2)
	1170	__attribute__nonnull__(pTHX_1)
	1171	__attribute__nonnull__(pTHX_5); */
	1172
	1173	PERL_CALLCONV I32 Perl_foldEQ_utf8_flags(pTHX_ const char s1, char pe1, UV l1, bool u1, const char s2, char **pe2, UV l2, bool u2, U32 flags)
	1174	__attribute__nonnull__(pTHX_1)
	1175	__attribute__nonnull__(pTHX_5);
	1176	#define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \
	1177	assert(s1); assert(s2)
	1178
	1179	PERL_CALLCONV char* Perl_form(pTHX_ const char* pat, ...)
	1180	__attribute__format__(__printf__,pTHX_1,pTHX_2)
	1181	__attribute__nonnull__(pTHX_1);
	1182	#define PERL_ARGS_ASSERT_FORM \
	1183	assert(pat)
	1184
	1185	PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX);
	1186	PERL_CALLCONV void Perl_free_tmps(pTHX);
	1187	PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags)
	1188	__attribute__nonnull__(pTHX_1);
	1189	#define PERL_ARGS_ASSERT_GET_AV \
	1190	assert(name)
	1191
	1192	PERL_CALLCONV void* Perl_get_context(void)
	1193	__attribute__warn_unused_result__;
	1194
	1195	PERL_CALLCONV CV* Perl_get_cv(pTHX_ const char* name, I32 flags)
	1196	__attribute__nonnull__(pTHX_1);
	1197	#define PERL_ARGS_ASSERT_GET_CV \
	1198	assert(name)
	1199
	1200	PERL_CALLCONV CV* Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 flags)
	1201	__attribute__nonnull__(pTHX_1);
	1202	#define PERL_ARGS_ASSERT_GET_CVN_FLAGS \
	1203	assert(name)
	1204
	1205	PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV *svp, CV cv)
	1206	__attribute__nonnull__(pTHX_2);
	1207	#define PERL_ARGS_ASSERT_GET_DB_SUB \
	1208	assert(cv)
	1209
	1210	PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer)
	1211	__attribute__nonnull__(pTHX_1);
	1212	#define PERL_ARGS_ASSERT_GET_HASH_SEED \
	1213	assert(seed_buffer)
	1214
	1215	PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags)
	1216	__attribute__nonnull__(pTHX_1);
	1217	#define PERL_ARGS_ASSERT_GET_HV \
	1218	assert(name)
	1219
	1220	PERL_CALLCONV const char* Perl_get_no_modify(pTHX)
	1221	__attribute__warn_unused_result__
	1222	__attribute__pure__;
	1223
	1224	PERL_CALLCONV char** Perl_get_op_descs(pTHX)
	1225	__attribute__warn_unused_result__
	1226	__attribute__pure__;
	1227
	1228	PERL_CALLCONV char** Perl_get_op_names(pTHX)
	1229	__attribute__warn_unused_result__
	1230	__attribute__pure__;
	1231
	1232	PERL_CALLCONV U32* Perl_get_opargs(pTHX)
	1233	__attribute__warn_unused_result__
	1234	__attribute__pure__;
	1235
	1236	PERL_CALLCONV PPADDR_t* Perl_get_ppaddr(pTHX)
	1237	__attribute__warn_unused_result__
	1238	__attribute__pure__;
	1239
	1240	PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv);
	1241	PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags)
	1242	__attribute__nonnull__(pTHX_1);
	1243	#define PERL_ARGS_ASSERT_GET_SV \
	1244	assert(name)
	1245
	1246	PERL_CALLCONV MGVTBL* Perl_get_vtbl(pTHX_ int vtbl_id)
	1247	__attribute__warn_unused_result__;
	1248
	1249	PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv)
	1250	__attribute__nonnull__(pTHX_1);
	1251	#define PERL_ARGS_ASSERT_GETCWD_SV \
	1252	assert(sv)
	1253
	1254	PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv);
	1255	PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp);
	1256	PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result)
	1257	__attribute__nonnull__(pTHX_1)
	1258	__attribute__nonnull__(pTHX_2)
	1259	__attribute__nonnull__(pTHX_3);
	1260	#define PERL_ARGS_ASSERT_GROK_BIN \
	1261	assert(start); assert(len_p); assert(flags)
	1262
	1263	PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result)
	1264	__attribute__nonnull__(pTHX_1)
	1265	__attribute__nonnull__(pTHX_2)
	1266	__attribute__nonnull__(pTHX_3);
	1267	#define PERL_ARGS_ASSERT_GROK_HEX \
	1268	assert(start); assert(len_p); assert(flags)
	1269
	1270	PERL_CALLCONV int Perl_grok_number(pTHX_ const char pv, STRLEN len, UV valuep)
	1271	__attribute__nonnull__(pTHX_1);
	1272	#define PERL_ARGS_ASSERT_GROK_NUMBER \
	1273	assert(pv)
	1274
	1275	PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char *sp, const char send)
	1276	__attribute__warn_unused_result__
	1277	__attribute__nonnull__(pTHX_1)
	1278	__attribute__nonnull__(pTHX_2);
	1279	#define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \
	1280	assert(sp); assert(send)
	1281
	1282	PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result)
	1283	__attribute__nonnull__(pTHX_1)
	1284	__attribute__nonnull__(pTHX_2)
	1285	__attribute__nonnull__(pTHX_3);
	1286	#define PERL_ARGS_ASSERT_GROK_OCT \
	1287	assert(start); assert(len_p); assert(flags)
	1288
	1289	/* PERL_CALLCONV GV* Perl_gv_AVadd(pTHX_ GV gv); /
	1290	/* PERL_CALLCONV GV* Perl_gv_HVadd(pTHX_ GV gv); /
	1291	/* PERL_CALLCONV GV* Perl_gv_IOadd(pTHX_ GV* gv); */
	1292	PERL_CALLCONV GV* Perl_gv_add_by_type(pTHX_ GV *gv, svtype type);
	1293	/* PERL_CALLCONV GV* gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method)
	1294	__attribute__warn_unused_result__
	1295	__attribute__nonnull__(pTHX_2); */
	1296
	1297	PERL_CALLCONV GV* Perl_gv_autoload_pv(pTHX_ HV* stash, const char* namepv, U32 flags)
	1298	__attribute__warn_unused_result__
	1299	__attribute__nonnull__(pTHX_2);
	1300	#define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \
	1301	assert(namepv)
	1302
	1303	PERL_CALLCONV GV* Perl_gv_autoload_pvn(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags)
	1304	__attribute__warn_unused_result__
	1305	__attribute__nonnull__(pTHX_2);
	1306	#define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \
	1307	assert(name)
	1308
	1309	PERL_CALLCONV GV* Perl_gv_autoload_sv(pTHX_ HV* stash, SV* namesv, U32 flags)
	1310	__attribute__warn_unused_result__
	1311	__attribute__nonnull__(pTHX_2);
	1312	#define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \
	1313	assert(namesv)
	1314
	1315	PERL_CALLCONV void Perl_gv_check(pTHX_ HV* stash)
	1316	__attribute__nonnull__(pTHX_1);
	1317	#define PERL_ARGS_ASSERT_GV_CHECK \
	1318	assert(stash)
	1319
	1320	PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv)
	1321	__attribute__warn_unused_result__
	1322	__attribute__nonnull__(pTHX_1);
	1323	#define PERL_ARGS_ASSERT_GV_CONST_SV \
	1324	assert(gv)
	1325
	1326	PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv)
	1327	__attribute__nonnull__(pTHX_1);
	1328	#define PERL_ARGS_ASSERT_GV_DUMP \
	1329	assert(gv)
	1330
	1331	PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv)
	1332	__attribute__nonnull__(pTHX_1)
	1333	__attribute__nonnull__(pTHX_2);
	1334	#define PERL_ARGS_ASSERT_GV_EFULLNAME \
	1335	assert(sv); assert(gv)
	1336
	1337	/* PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix)
	1338	__attribute__nonnull__(pTHX_1)
	1339	__attribute__nonnull__(pTHX_2); */
	1340	#define PERL_ARGS_ASSERT_GV_EFULLNAME3 \
	1341	assert(sv); assert(gv)
	1342
	1343	PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain)
	1344	__attribute__nonnull__(pTHX_1)
	1345	__attribute__nonnull__(pTHX_2);
	1346	#define PERL_ARGS_ASSERT_GV_EFULLNAME4 \
	1347	assert(sv); assert(gv)
	1348
	1349	PERL_CALLCONV GV* Perl_gv_fetchfile(pTHX_ const char* name)
	1350	__attribute__nonnull__(pTHX_1);
	1351	#define PERL_ARGS_ASSERT_GV_FETCHFILE \
	1352	assert(name)
	1353
	1354	PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN len, const U32 flags)
	1355	__attribute__nonnull__(pTHX_1);
	1356	#define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \
	1357	assert(name)
	1358
	1359	/* PERL_CALLCONV GV* gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level)
	1360	__attribute__nonnull__(pTHX_2); */
	1361
	1362	/* PERL_CALLCONV GV* gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level)
	1363	__attribute__nonnull__(pTHX_2); */
	1364
	1365	PERL_CALLCONV GV* Perl_gv_fetchmeth_pv(pTHX_ HV* stash, const char* name, I32 level, U32 flags)
	1366	__attribute__nonnull__(pTHX_2);
	1367	#define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \
	1368	assert(name)
	1369
	1370	PERL_CALLCONV GV* Perl_gv_fetchmeth_pv_autoload(pTHX_ HV* stash, const char* name, I32 level, U32 flags)
	1371	__attribute__nonnull__(pTHX_2);
	1372	#define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \
	1373	assert(name)
	1374
	1375	PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags)
	1376	__attribute__nonnull__(pTHX_2);
	1377	#define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \
	1378	assert(name)
	1379
	1380	PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags)
	1381	__attribute__nonnull__(pTHX_2);
	1382	#define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \
	1383	assert(name)
	1384
	1385	PERL_CALLCONV GV* Perl_gv_fetchmeth_sv(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags)
	1386	__attribute__nonnull__(pTHX_2);
	1387	#define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \
	1388	assert(namesv)
	1389
	1390	PERL_CALLCONV GV* Perl_gv_fetchmeth_sv_autoload(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags)
	1391	__attribute__nonnull__(pTHX_2);
	1392	#define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \
	1393	assert(namesv)
	1394
	1395	/* PERL_CALLCONV GV* Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name)
	1396	__attribute__nonnull__(pTHX_1)
	1397	__attribute__nonnull__(pTHX_2); */
	1398	#define PERL_ARGS_ASSERT_GV_FETCHMETHOD \
	1399	assert(stash); assert(name)
	1400
	1401	PERL_CALLCONV GV* Perl_gv_fetchmethod_autoload(pTHX_ HV* stash, const char* name, I32 autoload)
	1402	__attribute__nonnull__(pTHX_1)
	1403	__attribute__nonnull__(pTHX_2);
	1404	#define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \
	1405	assert(stash); assert(name)
	1406
	1407	PERL_CALLCONV GV* Perl_gv_fetchmethod_pv_flags(pTHX_ HV* stash, const char* name, U32 flags)
	1408	__attribute__nonnull__(pTHX_1)
	1409	__attribute__nonnull__(pTHX_2);
	1410	#define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \
	1411	assert(stash); assert(name)
	1412
	1413	PERL_CALLCONV GV* Perl_gv_fetchmethod_pvn_flags(pTHX_ HV* stash, const char* name, const STRLEN len, U32 flags)
	1414	__attribute__nonnull__(pTHX_1)
	1415	__attribute__nonnull__(pTHX_2);
	1416	#define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \
	1417	assert(stash); assert(name)
	1418
	1419	PERL_CALLCONV GV* Perl_gv_fetchmethod_sv_flags(pTHX_ HV* stash, SV* namesv, U32 flags)
	1420	__attribute__nonnull__(pTHX_1)
	1421	__attribute__nonnull__(pTHX_2);
	1422	#define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \
	1423	assert(stash); assert(namesv)
	1424
	1425	PERL_CALLCONV GV* Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type)
	1426	__attribute__nonnull__(pTHX_1);
	1427	#define PERL_ARGS_ASSERT_GV_FETCHPV \
	1428	assert(nambeg)
	1429
	1430	PERL_CALLCONV GV* Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type)
	1431	__attribute__nonnull__(pTHX_1);
	1432	#define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \
	1433	assert(name)
	1434
	1435	PERL_CALLCONV GV* Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type)
	1436	__attribute__nonnull__(pTHX_1);
	1437	#define PERL_ARGS_ASSERT_GV_FETCHSV \
	1438	assert(name)
	1439
	1440	PERL_CALLCONV void Perl_gv_fullname(pTHX_ SV* sv, const GV* gv)
	1441	__attribute__nonnull__(pTHX_1)
	1442	__attribute__nonnull__(pTHX_2);
	1443	#define PERL_ARGS_ASSERT_GV_FULLNAME \
	1444	assert(sv); assert(gv)
	1445
	1446	/* PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix)
	1447	__attribute__nonnull__(pTHX_1)
	1448	__attribute__nonnull__(pTHX_2); */
	1449	#define PERL_ARGS_ASSERT_GV_FULLNAME3 \
	1450	assert(sv); assert(gv)
	1451
	1452	PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain)
	1453	__attribute__nonnull__(pTHX_1)
	1454	__attribute__nonnull__(pTHX_2);
	1455	#define PERL_ARGS_ASSERT_GV_FULLNAME4 \
	1456	assert(sv); assert(gv)
	1457
	1458	PERL_CALLCONV CV* Perl_gv_handler(pTHX_ HV* stash, I32 id)
	1459	__attribute__warn_unused_result__;
	1460
	1461	/* PERL_CALLCONV void gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi)
	1462	__attribute__nonnull__(pTHX_1)
	1463	__attribute__nonnull__(pTHX_3); */
	1464
	1465	PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV* gv, HV* stash, const char* name, U32 flags)
	1466	__attribute__nonnull__(pTHX_1)
	1467	__attribute__nonnull__(pTHX_3);
	1468	#define PERL_ARGS_ASSERT_GV_INIT_PV \
	1469	assert(gv); assert(name)
	1470
	1471	PERL_CALLCONV void Perl_gv_init_pvn(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, U32 flags)
	1472	__attribute__nonnull__(pTHX_1)
	1473	__attribute__nonnull__(pTHX_3);
	1474	#define PERL_ARGS_ASSERT_GV_INIT_PVN \
	1475	assert(gv); assert(name)
	1476
	1477	PERL_CALLCONV void Perl_gv_init_sv(pTHX_ GV* gv, HV* stash, SV* namesv, U32 flags)
	1478	__attribute__nonnull__(pTHX_1)
	1479	__attribute__nonnull__(pTHX_3);
	1480	#define PERL_ARGS_ASSERT_GV_INIT_SV \
	1481	assert(gv); assert(namesv)
	1482
	1483	PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32 flags)
	1484	__attribute__nonnull__(pTHX_1)
	1485	__attribute__nonnull__(pTHX_2);
	1486	#define PERL_ARGS_ASSERT_GV_NAME_SET \
	1487	assert(gv); assert(name)
	1488
	1489	PERL_CALLCONV GV * Perl_gv_override(pTHX_ const char * const name, const STRLEN len)
	1490	__attribute__nonnull__(pTHX_1);
	1491	#define PERL_ARGS_ASSERT_GV_OVERRIDE \
	1492	assert(name)
	1493
	1494	PERL_CALLCONV HV* Perl_gv_stashpv(pTHX_ const char* name, I32 flags)
	1495	__attribute__nonnull__(pTHX_1);
	1496	#define PERL_ARGS_ASSERT_GV_STASHPV \
	1497	assert(name)
	1498
	1499	PERL_CALLCONV HV* Perl_gv_stashpvn(pTHX_ const char* name, U32 namelen, I32 flags)
	1500	__attribute__nonnull__(pTHX_1);
	1501	#define PERL_ARGS_ASSERT_GV_STASHPVN \
	1502	assert(name)
	1503
	1504	PERL_CALLCONV HV* Perl_gv_stashsv(pTHX_ SV* sv, I32 flags)
	1505	__attribute__nonnull__(pTHX_1);
	1506	#define PERL_ARGS_ASSERT_GV_STASHSV \
	1507	assert(sv)
	1508
	1509	PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV* gv)
	1510	__attribute__nonnull__(pTHX_1);
	1511	#define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \
	1512	assert(gv)
	1513
	1514	PERL_CALLCONV AV** Perl_hv_backreferences_p(pTHX_ HV *hv)
	1515	__attribute__nonnull__(pTHX_1);
	1516	#define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \
	1517	assert(hv)
	1518
	1519	PERL_CALLCONV void Perl_hv_clear(pTHX_ HV *hv);
	1520	PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv)
	1521	__attribute__nonnull__(pTHX_1);
	1522	#define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \
	1523	assert(hv)
	1524
	1525	PERL_CALLCONV void* Perl_hv_common(pTHX_ HV hv, SV keysv, const char* key, STRLEN klen, int flags, int action, SV *val, U32 hash);
	1526	PERL_CALLCONV void* Perl_hv_common_key_len(pTHX_ HV hv, const char key, I32 klen_i32, const int action, SV *val, const U32 hash)
	1527	__attribute__nonnull__(pTHX_2);
	1528	#define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \
	1529	assert(key)
	1530
	1531	PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV *const ohv)
	1532	__attribute__warn_unused_result__;
	1533
	1534	PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV hv, HE entry)
	1535	__attribute__nonnull__(pTHX_1);
	1536	#define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \
	1537	assert(hv)
	1538
	1539	/* PERL_CALLCONV SV* Perl_hv_delete(pTHX_ HV hv, const char key, I32 klen, I32 flags)
	1540	__attribute__nonnull__(pTHX_2); */
	1541	#define PERL_ARGS_ASSERT_HV_DELETE \
	1542	assert(key)
	1543
	1544	/* PERL_CALLCONV SV* Perl_hv_delete_ent(pTHX_ HV hv, SV keysv, I32 flags, U32 hash)
	1545	__attribute__nonnull__(pTHX_2); */
	1546	#define PERL_ARGS_ASSERT_HV_DELETE_ENT \
	1547	assert(keysv)
	1548
	1549	PERL_CALLCONV HE** Perl_hv_eiter_p(pTHX_ HV *hv)
	1550	__attribute__warn_unused_result__
	1551	__attribute__nonnull__(pTHX_1);
	1552	#define PERL_ARGS_ASSERT_HV_EITER_P \
	1553	assert(hv)
	1554
	1555	PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV hv, HE eiter)
	1556	__attribute__nonnull__(pTHX_1);
	1557	#define PERL_ARGS_ASSERT_HV_EITER_SET \
	1558	assert(hv)
	1559
	1560	PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV hv, const char name, U32 len, U32 flags)
	1561	__attribute__nonnull__(pTHX_1)
	1562	__attribute__nonnull__(pTHX_2);
	1563	#define PERL_ARGS_ASSERT_HV_ENAME_ADD \
	1564	assert(hv); assert(name)
	1565
	1566	PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV hv, const char name, U32 len, U32 flags)
	1567	__attribute__nonnull__(pTHX_1)
	1568	__attribute__nonnull__(pTHX_2);
	1569	#define PERL_ARGS_ASSERT_HV_ENAME_DELETE \
	1570	assert(hv); assert(name)
	1571
	1572	/* PERL_CALLCONV bool Perl_hv_exists(pTHX_ HV hv, const char key, I32 klen)
	1573	__attribute__warn_unused_result__
	1574	__attribute__nonnull__(pTHX_2); */
	1575	#define PERL_ARGS_ASSERT_HV_EXISTS \
	1576	assert(key)
	1577
	1578	/* PERL_CALLCONV bool Perl_hv_exists_ent(pTHX_ HV hv, SV keysv, U32 hash)
	1579	__attribute__warn_unused_result__
	1580	__attribute__nonnull__(pTHX_2); */
	1581	#define PERL_ARGS_ASSERT_HV_EXISTS_ENT \
	1582	assert(keysv)
	1583
	1584	/* PERL_CALLCONV SV** Perl_hv_fetch(pTHX_ HV hv, const char key, I32 klen, I32 lval)
	1585	__attribute__nonnull__(pTHX_2); */
	1586	#define PERL_ARGS_ASSERT_HV_FETCH \
	1587	assert(key)
	1588
	1589	/* PERL_CALLCONV HE* Perl_hv_fetch_ent(pTHX_ HV hv, SV keysv, I32 lval, U32 hash)
	1590	__attribute__nonnull__(pTHX_2); */
	1591	#define PERL_ARGS_ASSERT_HV_FETCH_ENT \
	1592	assert(keysv)
	1593
	1594	PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV *const hv)
	1595	__attribute__nonnull__(pTHX_1);
	1596	#define PERL_ARGS_ASSERT_HV_FILL \
	1597	assert(hv)
	1598
	1599	PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV hv, HE entry)
	1600	__attribute__nonnull__(pTHX_1);
	1601	#define PERL_ARGS_ASSERT_HV_FREE_ENT \
	1602	assert(hv)
	1603
	1604	PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv)
	1605	__attribute__nonnull__(pTHX_1);
	1606	#define PERL_ARGS_ASSERT_HV_ITERINIT \
	1607	assert(hv)
	1608
	1609	PERL_CALLCONV char* Perl_hv_iterkey(pTHX_ HE* entry, I32* retlen)
	1610	__attribute__warn_unused_result__
	1611	__attribute__nonnull__(pTHX_1)
	1612	__attribute__nonnull__(pTHX_2);
	1613	#define PERL_ARGS_ASSERT_HV_ITERKEY \
	1614	assert(entry); assert(retlen)
	1615
	1616	PERL_CALLCONV SV* Perl_hv_iterkeysv(pTHX_ HE* entry)
	1617	__attribute__warn_unused_result__
	1618	__attribute__nonnull__(pTHX_1);
	1619	#define PERL_ARGS_ASSERT_HV_ITERKEYSV \
	1620	assert(entry)
	1621
	1622	/* PERL_CALLCONV HE* Perl_hv_iternext(pTHX_ HV *hv)
	1623	__attribute__warn_unused_result__
	1624	__attribute__nonnull__(pTHX_1); */
	1625	#define PERL_ARGS_ASSERT_HV_ITERNEXT \
	1626	assert(hv)
	1627
	1628	PERL_CALLCONV HE* Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags)
	1629	__attribute__warn_unused_result__
	1630	__attribute__nonnull__(pTHX_1);
	1631	#define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \
	1632	assert(hv)
	1633
	1634	PERL_CALLCONV SV* Perl_hv_iternextsv(pTHX_ HV hv, char key, I32 retlen)
	1635	__attribute__warn_unused_result__
	1636	__attribute__nonnull__(pTHX_1)
	1637	__attribute__nonnull__(pTHX_2)
	1638	__attribute__nonnull__(pTHX_3);
	1639	#define PERL_ARGS_ASSERT_HV_ITERNEXTSV \
	1640	assert(hv); assert(key); assert(retlen)
	1641
	1642	PERL_CALLCONV SV* Perl_hv_iterval(pTHX_ HV hv, HE entry)
	1643	__attribute__warn_unused_result__
	1644	__attribute__nonnull__(pTHX_1)
	1645	__attribute__nonnull__(pTHX_2);
	1646	#define PERL_ARGS_ASSERT_HV_ITERVAL \
	1647	assert(hv); assert(entry)
	1648
	1649	PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax)
	1650	__attribute__nonnull__(pTHX_1);
	1651	#define PERL_ARGS_ASSERT_HV_KSPLIT \
	1652	assert(hv)
	1653
	1654	/* PERL_CALLCONV void Perl_hv_magic(pTHX_ HV hv, GV gv, int how)
	1655	__attribute__nonnull__(pTHX_1); */
	1656	#define PERL_ARGS_ASSERT_HV_MAGIC \
	1657	assert(hv)
	1658
	1659	PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV hv, const char name, U32 len, U32 flags)
	1660	__attribute__nonnull__(pTHX_1);
	1661	#define PERL_ARGS_ASSERT_HV_NAME_SET \
	1662	assert(hv)
	1663
	1664	PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv)
	1665	__attribute__warn_unused_result__
	1666	__attribute__nonnull__(pTHX_1);
	1667	#define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \
	1668	assert(hv)
	1669
	1670	PERL_CALLCONV SSize_t* Perl_hv_placeholders_p(pTHX_ HV *hv)
	1671	__attribute__warn_unused_result__
	1672	__attribute__nonnull__(pTHX_1);
	1673	#define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \
	1674	assert(hv)
	1675
	1676	PERL_CALLCONV void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph)
	1677	__attribute__nonnull__(pTHX_1);
	1678	#define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \
	1679	assert(hv)
	1680
	1681	PERL_CALLCONV void Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand)
	1682	__attribute__nonnull__(pTHX_1);
	1683	#define PERL_ARGS_ASSERT_HV_RAND_SET \
	1684	assert(hv)
	1685
	1686	PERL_CALLCONV I32* Perl_hv_riter_p(pTHX_ HV *hv)
	1687	__attribute__warn_unused_result__
	1688	__attribute__nonnull__(pTHX_1);
	1689	#define PERL_ARGS_ASSERT_HV_RITER_P \
	1690	assert(hv)
	1691
	1692	PERL_CALLCONV void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter)
	1693	__attribute__nonnull__(pTHX_1);
	1694	#define PERL_ARGS_ASSERT_HV_RITER_SET \
	1695	assert(hv)
	1696
	1697	PERL_CALLCONV SV* Perl_hv_scalar(pTHX_ HV *hv)
	1698	__attribute__warn_unused_result__
	1699	__attribute__nonnull__(pTHX_1);
	1700	#define PERL_ARGS_ASSERT_HV_SCALAR \
	1701	assert(hv)
	1702
	1703	/* PERL_CALLCONV SV** Perl_hv_store(pTHX_ HV hv, const char key, I32 klen, SV val, U32 hash); /
	1704	/* PERL_CALLCONV HE* Perl_hv_store_ent(pTHX_ HV hv, SV key, SV val, U32 hash); /
	1705	/* PERL_CALLCONV SV** Perl_hv_store_flags(pTHX_ HV hv, const char key, I32 klen, SV val, U32 hash, int flags); /
	1706	/* PERL_CALLCONV void hv_undef(pTHX_ HV hv); /
	1707	PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags);
	1708	/* PERL_CALLCONV I32 ibcmp(pTHX_ const char* a, const char* b, I32 len)
	1709	__attribute__nonnull__(pTHX_1)
	1710	__attribute__nonnull__(pTHX_2); */
	1711
	1712	/* PERL_CALLCONV I32 ibcmp_locale(pTHX_ const char* a, const char* b, I32 len)
	1713	__attribute__nonnull__(pTHX_1)
	1714	__attribute__nonnull__(pTHX_2); */
	1715
	1716	/* PERL_CALLCONV I32 ibcmp_utf8(pTHX_ const char s1, char pe1, UV l1, bool u1, const char s2, char **pe2, UV l2, bool u2)
	1717	__attribute__nonnull__(pTHX_1)
	1718	__attribute__nonnull__(pTHX_5); */
	1719
	1720	PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv)
	1721	__attribute__nonnull__(pTHX_2);
	1722	#define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \
	1723	assert(argv)
	1724
	1725	PERL_CALLCONV void Perl_init_constants(pTHX);
	1726	PERL_CALLCONV void Perl_init_dbargs(pTHX);
	1727	PERL_CALLCONV void Perl_init_debugger(pTHX);
	1728	PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn);
	1729	PERL_CALLCONV int Perl_init_i18nl14n(pTHX_ int printwarn);
	1730	PERL_CALLCONV void Perl_init_stacks(pTHX);
	1731	PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm)
	1732	__attribute__nonnull__(pTHX_1);
	1733	#define PERL_ARGS_ASSERT_INIT_TM \
	1734	assert(ptm)
	1735
	1736	PERL_CALLCONV char* Perl_instr(const char* big, const char* little)
	1737	__attribute__warn_unused_result__
	1738	__attribute__pure__
	1739	__attribute__nonnull__(1)
	1740	__attribute__nonnull__(2);
	1741	#define PERL_ARGS_ASSERT_INSTR \
	1742	assert(big); assert(little)
	1743
	1744	PERL_CALLCONV U32 Perl_intro_my(pTHX);
	1745	PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd)
	1746	__attribute__warn_unused_result__;
	1747
	1748	PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, bool not_implicit)
	1749	__attribute__nonnull__(pTHX_1);
	1750	#define PERL_ARGS_ASSERT_IO_CLOSE \
	1751	assert(io)
	1752
	1753	PERL_STATIC_INLINE bool S_isALNUM_lazy(pTHX_ const char* p)
	1754	__attribute__deprecated__
	1755	__attribute__warn_unused_result__
	1756	__attribute__pure__
	1757	__attribute__nonnull__(pTHX_1);
	1758	#define PERL_ARGS_ASSERT_ISALNUM_LAZY \
	1759	assert(p)
	1760
	1761	PERL_STATIC_INLINE bool S_isIDFIRST_lazy(pTHX_ const char* p)
	1762	__attribute__deprecated__
	1763	__attribute__warn_unused_result__
	1764	__attribute__pure__
	1765	__attribute__nonnull__(pTHX_1);
	1766	#define PERL_ARGS_ASSERT_ISIDFIRST_LAZY \
	1767	assert(p)
	1768
	1769	PERL_CALLCONV bool Perl_is_ascii_string(const U8 *s, STRLEN len)
	1770	__attribute__nonnull__(1);
	1771	#define PERL_ARGS_ASSERT_IS_ASCII_STRING \
	1772	assert(s)
	1773
	1774	PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX)
	1775	__attribute__warn_unused_result__;
	1776
	1777	PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char pv, STRLEN len, const char what, const char *op_name)
	1778	__attribute__warn_unused_result__
	1779	__attribute__nonnull__(pTHX_1)
	1780	__attribute__nonnull__(pTHX_3)
	1781	__attribute__nonnull__(pTHX_4);
	1782	#define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \
	1783	assert(pv); assert(what); assert(op_name)
	1784
	1785	PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c)
	1786	__attribute__deprecated__
	1787	__attribute__warn_unused_result__
	1788	__attribute__pure__;
	1789
	1790	PERL_CALLCONV bool Perl_is_uni_alnum_lc(pTHX_ UV c)
	1791	__attribute__deprecated__
	1792	__attribute__warn_unused_result__
	1793	__attribute__pure__;
	1794
	1795	PERL_CALLCONV bool Perl_is_uni_alnumc(pTHX_ UV c)
	1796	__attribute__deprecated__
	1797	__attribute__warn_unused_result__
	1798	__attribute__pure__;
	1799
	1800	PERL_CALLCONV bool Perl_is_uni_alnumc_lc(pTHX_ UV c)
	1801	__attribute__deprecated__
	1802	__attribute__warn_unused_result__
	1803	__attribute__pure__;
	1804
	1805	PERL_CALLCONV bool Perl_is_uni_alpha(pTHX_ UV c)
	1806	__attribute__deprecated__
	1807	__attribute__warn_unused_result__
	1808	__attribute__pure__;
	1809
	1810	PERL_CALLCONV bool Perl_is_uni_alpha_lc(pTHX_ UV c)
	1811	__attribute__deprecated__
	1812	__attribute__warn_unused_result__
	1813	__attribute__pure__;
	1814
	1815	PERL_CALLCONV bool Perl_is_uni_ascii(pTHX_ UV c)
	1816	__attribute__deprecated__
	1817	__attribute__warn_unused_result__
	1818	__attribute__pure__;
	1819
	1820	PERL_CALLCONV bool Perl_is_uni_ascii_lc(pTHX_ UV c)
	1821	__attribute__deprecated__
	1822	__attribute__warn_unused_result__
	1823	__attribute__pure__;
	1824
	1825	PERL_CALLCONV bool Perl_is_uni_blank(pTHX_ UV c)
	1826	__attribute__deprecated__
	1827	__attribute__warn_unused_result__
	1828	__attribute__pure__;
	1829
	1830	PERL_CALLCONV bool Perl_is_uni_blank_lc(pTHX_ UV c)
	1831	__attribute__deprecated__
	1832	__attribute__warn_unused_result__
	1833	__attribute__pure__;
	1834
	1835	PERL_CALLCONV bool Perl_is_uni_cntrl(pTHX_ UV c)
	1836	__attribute__deprecated__
	1837	__attribute__warn_unused_result__
	1838	__attribute__pure__;
	1839
	1840	PERL_CALLCONV bool Perl_is_uni_cntrl_lc(pTHX_ UV c)
	1841	__attribute__deprecated__
	1842	__attribute__warn_unused_result__
	1843	__attribute__pure__;
	1844
	1845	PERL_CALLCONV bool Perl_is_uni_digit(pTHX_ UV c)
	1846	__attribute__deprecated__
	1847	__attribute__warn_unused_result__
	1848	__attribute__pure__;
	1849
	1850	PERL_CALLCONV bool Perl_is_uni_digit_lc(pTHX_ UV c)
	1851	__attribute__deprecated__
	1852	__attribute__warn_unused_result__
	1853	__attribute__pure__;
	1854
	1855	PERL_CALLCONV bool Perl_is_uni_graph(pTHX_ UV c)
	1856	__attribute__deprecated__
	1857	__attribute__warn_unused_result__
	1858	__attribute__pure__;
	1859
	1860	PERL_CALLCONV bool Perl_is_uni_graph_lc(pTHX_ UV c)
	1861	__attribute__deprecated__
	1862	__attribute__warn_unused_result__
	1863	__attribute__pure__;
	1864
	1865	PERL_CALLCONV bool Perl_is_uni_idfirst(pTHX_ UV c)
	1866	__attribute__deprecated__
	1867	__attribute__warn_unused_result__
	1868	__attribute__pure__;
	1869
	1870	PERL_CALLCONV bool Perl_is_uni_idfirst_lc(pTHX_ UV c)
	1871	__attribute__deprecated__
	1872	__attribute__warn_unused_result__
	1873	__attribute__pure__;
	1874
	1875	PERL_CALLCONV bool Perl_is_uni_lower(pTHX_ UV c)
	1876	__attribute__deprecated__
	1877	__attribute__warn_unused_result__
	1878	__attribute__pure__;
	1879
	1880	PERL_CALLCONV bool Perl_is_uni_lower_lc(pTHX_ UV c)
	1881	__attribute__deprecated__
	1882	__attribute__warn_unused_result__
	1883	__attribute__pure__;
	1884
	1885	PERL_CALLCONV bool Perl_is_uni_print(pTHX_ UV c)
	1886	__attribute__deprecated__
	1887	__attribute__warn_unused_result__
	1888	__attribute__pure__;
	1889
	1890	PERL_CALLCONV bool Perl_is_uni_print_lc(pTHX_ UV c)
	1891	__attribute__deprecated__
	1892	__attribute__warn_unused_result__
	1893	__attribute__pure__;
	1894
	1895	PERL_CALLCONV bool Perl_is_uni_punct(pTHX_ UV c)
	1896	__attribute__deprecated__
	1897	__attribute__warn_unused_result__
	1898	__attribute__pure__;
	1899
	1900	PERL_CALLCONV bool Perl_is_uni_punct_lc(pTHX_ UV c)
	1901	__attribute__deprecated__
	1902	__attribute__warn_unused_result__
	1903	__attribute__pure__;
	1904
	1905	PERL_CALLCONV bool Perl_is_uni_space(pTHX_ UV c)
	1906	__attribute__deprecated__
	1907	__attribute__warn_unused_result__
	1908	__attribute__pure__;
	1909
	1910	PERL_CALLCONV bool Perl_is_uni_space_lc(pTHX_ UV c)
	1911	__attribute__deprecated__
	1912	__attribute__warn_unused_result__
	1913	__attribute__pure__;
	1914
	1915	PERL_CALLCONV bool Perl_is_uni_upper(pTHX_ UV c)
	1916	__attribute__deprecated__
	1917	__attribute__warn_unused_result__
	1918	__attribute__pure__;
	1919
	1920	PERL_CALLCONV bool Perl_is_uni_upper_lc(pTHX_ UV c)
	1921	__attribute__deprecated__
	1922	__attribute__warn_unused_result__
	1923	__attribute__pure__;
	1924
	1925	PERL_CALLCONV bool Perl_is_uni_xdigit(pTHX_ UV c)
	1926	__attribute__deprecated__
	1927	__attribute__warn_unused_result__
	1928	__attribute__pure__;
	1929
	1930	PERL_CALLCONV bool Perl_is_uni_xdigit_lc(pTHX_ UV c)
	1931	__attribute__deprecated__
	1932	__attribute__warn_unused_result__
	1933	__attribute__pure__;
	1934
	1935	PERL_CALLCONV bool Perl_is_utf8_alnum(pTHX_ const U8 *p)
	1936	__attribute__deprecated__
	1937	__attribute__warn_unused_result__
	1938	__attribute__nonnull__(pTHX_1);
	1939	#define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \
	1940	assert(p)
	1941
	1942	PERL_CALLCONV bool Perl_is_utf8_alnumc(pTHX_ const U8 *p)
	1943	__attribute__deprecated__
	1944	__attribute__warn_unused_result__
	1945	__attribute__nonnull__(pTHX_1);
	1946	#define PERL_ARGS_ASSERT_IS_UTF8_ALNUMC \
	1947	assert(p)
	1948
	1949	PERL_CALLCONV bool Perl_is_utf8_alpha(pTHX_ const U8 *p)
	1950	__attribute__deprecated__
	1951	__attribute__warn_unused_result__
	1952	__attribute__nonnull__(pTHX_1);
	1953	#define PERL_ARGS_ASSERT_IS_UTF8_ALPHA \
	1954	assert(p)
	1955
	1956	PERL_CALLCONV bool Perl_is_utf8_ascii(pTHX_ const U8 *p)
	1957	__attribute__deprecated__
	1958	__attribute__warn_unused_result__
	1959	__attribute__nonnull__(pTHX_1);
	1960	#define PERL_ARGS_ASSERT_IS_UTF8_ASCII \
	1961	assert(p)
	1962
	1963	PERL_CALLCONV bool Perl_is_utf8_blank(pTHX_ const U8 *p)
	1964	__attribute__deprecated__
	1965	__attribute__warn_unused_result__
	1966	__attribute__nonnull__(pTHX_1);
	1967	#define PERL_ARGS_ASSERT_IS_UTF8_BLANK \
	1968	assert(p)
	1969
	1970	PERL_CALLCONV STRLEN Perl_is_utf8_char(const U8 *s)
	1971	__attribute__deprecated__
	1972	__attribute__nonnull__(1);
	1973	#define PERL_ARGS_ASSERT_IS_UTF8_CHAR \
	1974	assert(s)
	1975
	1976	PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 buf, const U8 buf_end)
	1977	__attribute__nonnull__(1)
	1978	__attribute__nonnull__(2);
	1979	#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \
	1980	assert(buf); assert(buf_end)
	1981
	1982	PERL_CALLCONV bool Perl_is_utf8_cntrl(pTHX_ const U8 *p)
	1983	__attribute__deprecated__
	1984	__attribute__warn_unused_result__
	1985	__attribute__nonnull__(pTHX_1);
	1986	#define PERL_ARGS_ASSERT_IS_UTF8_CNTRL \
	1987	assert(p)
	1988
	1989	PERL_CALLCONV bool Perl_is_utf8_digit(pTHX_ const U8 *p)
	1990	__attribute__deprecated__
	1991	__attribute__warn_unused_result__
	1992	__attribute__nonnull__(pTHX_1);
	1993	#define PERL_ARGS_ASSERT_IS_UTF8_DIGIT \
	1994	assert(p)
	1995
	1996	PERL_CALLCONV bool Perl_is_utf8_graph(pTHX_ const U8 *p)
	1997	__attribute__deprecated__
	1998	__attribute__warn_unused_result__
	1999	__attribute__nonnull__(pTHX_1);
	2000	#define PERL_ARGS_ASSERT_IS_UTF8_GRAPH \
	2001	assert(p)
	2002
	2003	PERL_CALLCONV bool Perl_is_utf8_idcont(pTHX_ const U8 *p)
	2004	__attribute__deprecated__
	2005	__attribute__warn_unused_result__
	2006	__attribute__nonnull__(pTHX_1);
	2007	#define PERL_ARGS_ASSERT_IS_UTF8_IDCONT \
	2008	assert(p)
	2009
	2010	PERL_CALLCONV bool Perl_is_utf8_idfirst(pTHX_ const U8 *p)
	2011	__attribute__deprecated__
	2012	__attribute__warn_unused_result__
	2013	__attribute__nonnull__(pTHX_1);
	2014	#define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST \
	2015	assert(p)
	2016
	2017	PERL_CALLCONV bool Perl_is_utf8_lower(pTHX_ const U8 *p)
	2018	__attribute__deprecated__
	2019	__attribute__warn_unused_result__
	2020	__attribute__nonnull__(pTHX_1);
	2021	#define PERL_ARGS_ASSERT_IS_UTF8_LOWER \
	2022	assert(p)
	2023
	2024	PERL_CALLCONV bool Perl_is_utf8_mark(pTHX_ const U8 *p)
	2025	__attribute__deprecated__
	2026	__attribute__warn_unused_result__
	2027	__attribute__nonnull__(pTHX_1);
	2028	#define PERL_ARGS_ASSERT_IS_UTF8_MARK \
	2029	assert(p)
	2030
	2031	PERL_CALLCONV bool Perl_is_utf8_perl_space(pTHX_ const U8 *p)
	2032	__attribute__deprecated__
	2033	__attribute__warn_unused_result__
	2034	__attribute__nonnull__(pTHX_1);
	2035	#define PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE \
	2036	assert(p)
	2037
	2038	PERL_CALLCONV bool Perl_is_utf8_perl_word(pTHX_ const U8 *p)
	2039	__attribute__deprecated__
	2040	__attribute__warn_unused_result__
	2041	__attribute__nonnull__(pTHX_1);
	2042	#define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD \
	2043	assert(p)
	2044
	2045	PERL_CALLCONV bool Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
	2046	__attribute__deprecated__
	2047	__attribute__warn_unused_result__
	2048	__attribute__nonnull__(pTHX_1);
	2049	#define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT \
	2050	assert(p)
	2051
	2052	PERL_CALLCONV bool Perl_is_utf8_print(pTHX_ const U8 *p)
	2053	__attribute__deprecated__
	2054	__attribute__warn_unused_result__
	2055	__attribute__nonnull__(pTHX_1);
	2056	#define PERL_ARGS_ASSERT_IS_UTF8_PRINT \
	2057	assert(p)
	2058
	2059	PERL_CALLCONV bool Perl_is_utf8_punct(pTHX_ const U8 *p)
	2060	__attribute__deprecated__
	2061	__attribute__warn_unused_result__
	2062	__attribute__nonnull__(pTHX_1);
	2063	#define PERL_ARGS_ASSERT_IS_UTF8_PUNCT \
	2064	assert(p)
	2065
	2066	PERL_CALLCONV bool Perl_is_utf8_space(pTHX_ const U8 *p)
	2067	__attribute__deprecated__
	2068	__attribute__warn_unused_result__
	2069	__attribute__nonnull__(pTHX_1);
	2070	#define PERL_ARGS_ASSERT_IS_UTF8_SPACE \
	2071	assert(p)
	2072
	2073	PERL_CALLCONV bool Perl_is_utf8_string(const U8 *s, STRLEN len)
	2074	__attribute__nonnull__(1);
	2075	#define PERL_ARGS_ASSERT_IS_UTF8_STRING \
	2076	assert(s)
	2077
	2078	/* PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 s, STRLEN len, const U8 *ep)
	2079	__attribute__nonnull__(1); */
	2080	#define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \
	2081	assert(s)
	2082
	2083	PERL_CALLCONV bool Perl_is_utf8_string_loclen(const U8 s, STRLEN len, const U8 ep, STRLEN el)
	2084	__attribute__nonnull__(1);
	2085	#define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \
	2086	assert(s)
	2087
	2088	PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p)
	2089	__attribute__deprecated__
	2090	__attribute__warn_unused_result__
	2091	__attribute__nonnull__(pTHX_1);
	2092	#define PERL_ARGS_ASSERT_IS_UTF8_UPPER \
	2093	assert(p)
	2094
	2095	PERL_CALLCONV bool Perl_is_utf8_xdigit(pTHX_ const U8 *p)
	2096	__attribute__deprecated__
	2097	__attribute__warn_unused_result__
	2098	__attribute__nonnull__(pTHX_1);
	2099	#define PERL_ARGS_ASSERT_IS_UTF8_XDIGIT \
	2100	assert(p)
	2101
	2102	PERL_CALLCONV bool Perl_is_utf8_xidcont(pTHX_ const U8 *p)
	2103	__attribute__deprecated__
	2104	__attribute__warn_unused_result__
	2105	__attribute__nonnull__(pTHX_1);
	2106	#define PERL_ARGS_ASSERT_IS_UTF8_XIDCONT \
	2107	assert(p)
	2108
	2109	PERL_CALLCONV bool Perl_is_utf8_xidfirst(pTHX_ const U8 *p)
	2110	__attribute__deprecated__
	2111	__attribute__warn_unused_result__
	2112	__attribute__nonnull__(pTHX_1);
	2113	#define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST \
	2114	assert(p)
	2115
	2116	PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o)
	2117	__attribute__nonnull__(pTHX_1);
	2118	#define PERL_ARGS_ASSERT_JMAYBE \
	2119	assert(o)
	2120
	2121	PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords)
	2122	__attribute__pure__
	2123	__attribute__nonnull__(pTHX_1);
	2124	#define PERL_ARGS_ASSERT_KEYWORD \
	2125	assert(name)
	2126
	2127	PERL_CALLCONV int Perl_keyword_plugin_standard(pTHX_ char* keyword_ptr, STRLEN keyword_len, OP** op_ptr)
	2128	__attribute__nonnull__(pTHX_1)
	2129	__attribute__nonnull__(pTHX_3);
	2130	#define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \
	2131	assert(keyword_ptr); assert(op_ptr)
	2132
	2133	PERL_CALLCONV void Perl_leave_scope(pTHX_ I32 base);
	2134	PERL_CALLCONV bool Perl_lex_bufutf8(pTHX);
	2135	PERL_CALLCONV void Perl_lex_discard_to(pTHX_ char* ptr)
	2136	__attribute__nonnull__(pTHX_1);
	2137	#define PERL_ARGS_ASSERT_LEX_DISCARD_TO \
	2138	assert(ptr)
	2139
	2140	PERL_CALLCONV char* Perl_lex_grow_linestr(pTHX_ STRLEN len);
	2141	PERL_CALLCONV bool Perl_lex_next_chunk(pTHX_ U32 flags);
	2142	PERL_CALLCONV I32 Perl_lex_peek_unichar(pTHX_ U32 flags);
	2143	PERL_CALLCONV void Perl_lex_read_space(pTHX_ U32 flags);
	2144	PERL_CALLCONV void Perl_lex_read_to(pTHX_ char* ptr)
	2145	__attribute__nonnull__(pTHX_1);
	2146	#define PERL_ARGS_ASSERT_LEX_READ_TO \
	2147	assert(ptr)
	2148
	2149	PERL_CALLCONV I32 Perl_lex_read_unichar(pTHX_ U32 flags);
	2150	PERL_CALLCONV void Perl_lex_start(pTHX_ SV* line, PerlIO *rsfp, U32 flags);
	2151	PERL_CALLCONV void Perl_lex_stuff_pv(pTHX_ const char* pv, U32 flags)
	2152	__attribute__nonnull__(pTHX_1);
	2153	#define PERL_ARGS_ASSERT_LEX_STUFF_PV \
	2154	assert(pv)
	2155
	2156	PERL_CALLCONV void Perl_lex_stuff_pvn(pTHX_ const char* pv, STRLEN len, U32 flags)
	2157	__attribute__nonnull__(pTHX_1);
	2158	#define PERL_ARGS_ASSERT_LEX_STUFF_PVN \
	2159	assert(pv)
	2160
	2161	PERL_CALLCONV void Perl_lex_stuff_sv(pTHX_ SV* sv, U32 flags)
	2162	__attribute__nonnull__(pTHX_1);
	2163	#define PERL_ARGS_ASSERT_LEX_STUFF_SV \
	2164	assert(sv)
	2165
	2166	PERL_CALLCONV void Perl_lex_unstuff(pTHX_ char* ptr)
	2167	__attribute__nonnull__(pTHX_1);
	2168	#define PERL_ARGS_ASSERT_LEX_UNSTUFF \
	2169	assert(ptr)
	2170
	2171	PERL_CALLCONV OP* Perl_list(pTHX_ OP* o);
	2172	PERL_CALLCONV void Perl_load_module(pTHX_ U32 flags, SV* name, SV* ver, ...)
	2173	__attribute__nonnull__(pTHX_2);
	2174	#define PERL_ARGS_ASSERT_LOAD_MODULE \
	2175	assert(name)
	2176
	2177	PERL_CALLCONV OP* Perl_localize(pTHX_ OP *o, I32 lex)
	2178	__attribute__nonnull__(pTHX_1);
	2179	#define PERL_ARGS_ASSERT_LOCALIZE \
	2180	assert(o)
	2181
	2182	PERL_CALLCONV I32 Perl_looks_like_number(pTHX_ SV *const sv)
	2183	__attribute__warn_unused_result__
	2184	__attribute__nonnull__(pTHX_1);
	2185	#define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \
	2186	assert(sv)
	2187
	2188	PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV* sv, MAGIC* mg)
	2189	__attribute__nonnull__(pTHX_1)
	2190	__attribute__nonnull__(pTHX_2);
	2191	#define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \
	2192	assert(sv); assert(mg)
	2193
	2194	PERL_CALLCONV int Perl_magic_cleararylen_p(pTHX_ SV* sv, MAGIC* mg)
	2195	__attribute__nonnull__(pTHX_1)
	2196	__attribute__nonnull__(pTHX_2);
	2197	#define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P \
	2198	assert(sv); assert(mg)
	2199
	2200	PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV* sv, MAGIC* mg)
	2201	__attribute__nonnull__(pTHX_1)
	2202	__attribute__nonnull__(pTHX_2);
	2203	#define PERL_ARGS_ASSERT_MAGIC_CLEARENV \
	2204	assert(sv); assert(mg)
	2205
	2206	PERL_CALLCONV int Perl_magic_clearhint(pTHX_ SV* sv, MAGIC* mg)
	2207	__attribute__nonnull__(pTHX_1)
	2208	__attribute__nonnull__(pTHX_2);
	2209	#define PERL_ARGS_ASSERT_MAGIC_CLEARHINT \
	2210	assert(sv); assert(mg)
	2211
	2212	PERL_CALLCONV int Perl_magic_clearhints(pTHX_ SV* sv, MAGIC* mg)
	2213	__attribute__nonnull__(pTHX_1)
	2214	__attribute__nonnull__(pTHX_2);
	2215	#define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS \
	2216	assert(sv); assert(mg)
	2217
	2218	PERL_CALLCONV int Perl_magic_clearisa(pTHX_ SV* sv, MAGIC* mg)
	2219	__attribute__nonnull__(pTHX_2);
	2220	#define PERL_ARGS_ASSERT_MAGIC_CLEARISA \
	2221	assert(mg)
	2222
	2223	PERL_CALLCONV int Perl_magic_clearpack(pTHX_ SV* sv, MAGIC* mg)
	2224	__attribute__nonnull__(pTHX_1)
	2225	__attribute__nonnull__(pTHX_2);
	2226	#define PERL_ARGS_ASSERT_MAGIC_CLEARPACK \
	2227	assert(sv); assert(mg)
	2228
	2229	PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV* sv, MAGIC* mg)
	2230	__attribute__nonnull__(pTHX_1)
	2231	__attribute__nonnull__(pTHX_2);
	2232	#define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \
	2233	assert(sv); assert(mg)
	2234
	2235	PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV* sv, MAGIC mg, SV nsv, const char *name, I32 namlen)
	2236	__attribute__nonnull__(pTHX_1)
	2237	__attribute__nonnull__(pTHX_2)
	2238	__attribute__nonnull__(pTHX_3);
	2239	#define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \
	2240	assert(sv); assert(mg); assert(nsv)
	2241
	2242	PERL_CALLCONV void Perl_magic_dump(pTHX_ const MAGIC *mg);
	2243	PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg)
	2244	__attribute__nonnull__(pTHX_1)
	2245	__attribute__nonnull__(pTHX_2);
	2246	#define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \
	2247	assert(sv); assert(mg)
	2248
	2249	PERL_CALLCONV int Perl_magic_freearylen_p(pTHX_ SV* sv, MAGIC* mg)
	2250	__attribute__nonnull__(pTHX_1)
	2251	__attribute__nonnull__(pTHX_2);
	2252	#define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P \
	2253	assert(sv); assert(mg)
	2254
	2255	PERL_CALLCONV int Perl_magic_freeovrld(pTHX_ SV* sv, MAGIC* mg)
	2256	__attribute__nonnull__(pTHX_1)
	2257	__attribute__nonnull__(pTHX_2);
	2258	#define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD \
	2259	assert(sv); assert(mg)
	2260
	2261	PERL_CALLCONV int Perl_magic_get(pTHX_ SV* sv, MAGIC* mg)
	2262	__attribute__nonnull__(pTHX_1)
	2263	__attribute__nonnull__(pTHX_2);
	2264	#define PERL_ARGS_ASSERT_MAGIC_GET \
	2265	assert(sv); assert(mg)
	2266
	2267	PERL_CALLCONV int Perl_magic_getarylen(pTHX_ SV* sv, const MAGIC* mg)
	2268	__attribute__nonnull__(pTHX_1)
	2269	__attribute__nonnull__(pTHX_2);
	2270	#define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \
	2271	assert(sv); assert(mg)
	2272
	2273	PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV* sv, MAGIC* mg)
	2274	__attribute__nonnull__(pTHX_1)
	2275	__attribute__nonnull__(pTHX_2);
	2276	#define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM \
	2277	assert(sv); assert(mg)
	2278
	2279	PERL_CALLCONV int Perl_magic_getnkeys(pTHX_ SV* sv, MAGIC* mg)
	2280	__attribute__nonnull__(pTHX_1)
	2281	__attribute__nonnull__(pTHX_2);
	2282	#define PERL_ARGS_ASSERT_MAGIC_GETNKEYS \
	2283	assert(sv); assert(mg)
	2284
	2285	PERL_CALLCONV int Perl_magic_getpack(pTHX_ SV* sv, MAGIC* mg)
	2286	__attribute__nonnull__(pTHX_1)
	2287	__attribute__nonnull__(pTHX_2);
	2288	#define PERL_ARGS_ASSERT_MAGIC_GETPACK \
	2289	assert(sv); assert(mg)
	2290
	2291	PERL_CALLCONV int Perl_magic_getpos(pTHX_ SV* sv, MAGIC* mg)
	2292	__attribute__nonnull__(pTHX_1)
	2293	__attribute__nonnull__(pTHX_2);
	2294	#define PERL_ARGS_ASSERT_MAGIC_GETPOS \
	2295	assert(sv); assert(mg)
	2296
	2297	PERL_CALLCONV int Perl_magic_getsig(pTHX_ SV* sv, MAGIC* mg)
	2298	__attribute__nonnull__(pTHX_1)
	2299	__attribute__nonnull__(pTHX_2);
	2300	#define PERL_ARGS_ASSERT_MAGIC_GETSIG \
	2301	assert(sv); assert(mg)
	2302
	2303	PERL_CALLCONV int Perl_magic_getsubstr(pTHX_ SV* sv, MAGIC* mg)
	2304	__attribute__nonnull__(pTHX_1)
	2305	__attribute__nonnull__(pTHX_2);
	2306	#define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR \
	2307	assert(sv); assert(mg)
	2308
	2309	PERL_CALLCONV int Perl_magic_gettaint(pTHX_ SV* sv, MAGIC* mg)
	2310	__attribute__nonnull__(pTHX_1)
	2311	__attribute__nonnull__(pTHX_2);
	2312	#define PERL_ARGS_ASSERT_MAGIC_GETTAINT \
	2313	assert(sv); assert(mg)
	2314
	2315	PERL_CALLCONV int Perl_magic_getuvar(pTHX_ SV* sv, MAGIC* mg)
	2316	__attribute__nonnull__(pTHX_1)
	2317	__attribute__nonnull__(pTHX_2);
	2318	#define PERL_ARGS_ASSERT_MAGIC_GETUVAR \
	2319	assert(sv); assert(mg)
	2320
	2321	PERL_CALLCONV int Perl_magic_getvec(pTHX_ SV* sv, MAGIC* mg)
	2322	__attribute__nonnull__(pTHX_1)
	2323	__attribute__nonnull__(pTHX_2);
	2324	#define PERL_ARGS_ASSERT_MAGIC_GETVEC \
	2325	assert(sv); assert(mg)
	2326
	2327	PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV sv, MAGIC mg)
	2328	__attribute__nonnull__(pTHX_1)
	2329	__attribute__nonnull__(pTHX_2);
	2330	#define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \
	2331	assert(sv); assert(mg)
	2332
	2333	PERL_CALLCONV SV* Perl_magic_methcall(pTHX_ SV sv, const MAGIC mg, SV *meth, U32 flags, U32 argc, ...)
	2334	__attribute__nonnull__(pTHX_1)
	2335	__attribute__nonnull__(pTHX_2)
	2336	__attribute__nonnull__(pTHX_3);
	2337	#define PERL_ARGS_ASSERT_MAGIC_METHCALL \
	2338	assert(sv); assert(mg); assert(meth)
	2339
	2340	PERL_CALLCONV int Perl_magic_nextpack(pTHX_ SV sv, MAGIC mg, SV *key)
	2341	__attribute__nonnull__(pTHX_1)
	2342	__attribute__nonnull__(pTHX_2)
	2343	__attribute__nonnull__(pTHX_3);
	2344	#define PERL_ARGS_ASSERT_MAGIC_NEXTPACK \
	2345	assert(sv); assert(mg); assert(key)
	2346
	2347	PERL_CALLCONV U32 Perl_magic_regdata_cnt(pTHX_ SV* sv, MAGIC* mg)
	2348	__attribute__nonnull__(pTHX_1)
	2349	__attribute__nonnull__(pTHX_2);
	2350	#define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT \
	2351	assert(sv); assert(mg)
	2352
	2353	PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV* sv, MAGIC* mg)
	2354	__attribute__nonnull__(pTHX_1)
	2355	__attribute__nonnull__(pTHX_2);
	2356	#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \
	2357	assert(sv); assert(mg)
	2358
	2359	PERL_CALLCONV SV* Perl_magic_scalarpack(pTHX_ HV hv, MAGIC mg)
	2360	__attribute__nonnull__(pTHX_1)
	2361	__attribute__nonnull__(pTHX_2);
	2362	#define PERL_ARGS_ASSERT_MAGIC_SCALARPACK \
	2363	assert(hv); assert(mg)
	2364
	2365	PERL_CALLCONV int Perl_magic_set(pTHX_ SV* sv, MAGIC* mg)
	2366	__attribute__nonnull__(pTHX_1)
	2367	__attribute__nonnull__(pTHX_2);
	2368	#define PERL_ARGS_ASSERT_MAGIC_SET \
	2369	assert(sv); assert(mg)
	2370
	2371	PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV* sv, MAGIC* mg)
	2372	__attribute__nonnull__(pTHX_1)
	2373	__attribute__nonnull__(pTHX_2);
	2374	#define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \
	2375	assert(sv); assert(mg)
	2376
	2377	PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV* sv, MAGIC* mg)
	2378	__attribute__nonnull__(pTHX_1)
	2379	__attribute__nonnull__(pTHX_2);
	2380	#define PERL_ARGS_ASSERT_MAGIC_SETARYLEN \
	2381	assert(sv); assert(mg)
	2382
	2383	PERL_CALLCONV int Perl_magic_setdbline(pTHX_ SV* sv, MAGIC* mg)
	2384	__attribute__nonnull__(pTHX_1)
	2385	__attribute__nonnull__(pTHX_2);
	2386	#define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \
	2387	assert(sv); assert(mg)
	2388
	2389	PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV* sv, MAGIC* mg)
	2390	__attribute__nonnull__(pTHX_1)
	2391	__attribute__nonnull__(pTHX_2);
	2392	#define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM \
	2393	assert(sv); assert(mg)
	2394
	2395	PERL_CALLCONV int Perl_magic_setenv(pTHX_ SV* sv, MAGIC* mg)
	2396	__attribute__nonnull__(pTHX_1)
	2397	__attribute__nonnull__(pTHX_2);
	2398	#define PERL_ARGS_ASSERT_MAGIC_SETENV \
	2399	assert(sv); assert(mg)
	2400
	2401	PERL_CALLCONV int Perl_magic_sethint(pTHX_ SV* sv, MAGIC* mg)
	2402	__attribute__nonnull__(pTHX_1)
	2403	__attribute__nonnull__(pTHX_2);
	2404	#define PERL_ARGS_ASSERT_MAGIC_SETHINT \
	2405	assert(sv); assert(mg)
	2406
	2407	PERL_CALLCONV int Perl_magic_setisa(pTHX_ SV* sv, MAGIC* mg)
	2408	__attribute__nonnull__(pTHX_1)
	2409	__attribute__nonnull__(pTHX_2);
	2410	#define PERL_ARGS_ASSERT_MAGIC_SETISA \
	2411	assert(sv); assert(mg)
	2412
	2413	PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV* sv, MAGIC* mg)
	2414	__attribute__nonnull__(pTHX_1)
	2415	__attribute__nonnull__(pTHX_2);
	2416	#define PERL_ARGS_ASSERT_MAGIC_SETMGLOB \
	2417	assert(sv); assert(mg)
	2418
	2419	PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV* sv, MAGIC* mg)
	2420	__attribute__nonnull__(pTHX_1)
	2421	__attribute__nonnull__(pTHX_2);
	2422	#define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \
	2423	assert(sv); assert(mg)
	2424
	2425	PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV* sv, MAGIC* mg)
	2426	__attribute__nonnull__(pTHX_1)
	2427	__attribute__nonnull__(pTHX_2);
	2428	#define PERL_ARGS_ASSERT_MAGIC_SETPACK \
	2429	assert(sv); assert(mg)
	2430
	2431	PERL_CALLCONV int Perl_magic_setpos(pTHX_ SV* sv, MAGIC* mg)
	2432	__attribute__nonnull__(pTHX_1)
	2433	__attribute__nonnull__(pTHX_2);
	2434	#define PERL_ARGS_ASSERT_MAGIC_SETPOS \
	2435	assert(sv); assert(mg)
	2436
	2437	PERL_CALLCONV int Perl_magic_setregexp(pTHX_ SV* sv, MAGIC* mg)
	2438	__attribute__nonnull__(pTHX_1)
	2439	__attribute__nonnull__(pTHX_2);
	2440	#define PERL_ARGS_ASSERT_MAGIC_SETREGEXP \
	2441	assert(sv); assert(mg)
	2442
	2443	PERL_CALLCONV int Perl_magic_setsig(pTHX_ SV* sv, MAGIC* mg)
	2444	__attribute__nonnull__(pTHX_2);
	2445	#define PERL_ARGS_ASSERT_MAGIC_SETSIG \
	2446	assert(mg)
	2447
	2448	PERL_CALLCONV int Perl_magic_setsubstr(pTHX_ SV* sv, MAGIC* mg)
	2449	__attribute__nonnull__(pTHX_1)
	2450	__attribute__nonnull__(pTHX_2);
	2451	#define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR \
	2452	assert(sv); assert(mg)
	2453
	2454	PERL_CALLCONV int Perl_magic_settaint(pTHX_ SV* sv, MAGIC* mg)
	2455	__attribute__nonnull__(pTHX_1)
	2456	__attribute__nonnull__(pTHX_2);
	2457	#define PERL_ARGS_ASSERT_MAGIC_SETTAINT \
	2458	assert(sv); assert(mg)
	2459
	2460	PERL_CALLCONV int Perl_magic_setutf8(pTHX_ SV* sv, MAGIC* mg)
	2461	__attribute__nonnull__(pTHX_1)
	2462	__attribute__nonnull__(pTHX_2);
	2463	#define PERL_ARGS_ASSERT_MAGIC_SETUTF8 \
	2464	assert(sv); assert(mg)
	2465
	2466	PERL_CALLCONV int Perl_magic_setuvar(pTHX_ SV* sv, MAGIC* mg)
	2467	__attribute__nonnull__(pTHX_1)
	2468	__attribute__nonnull__(pTHX_2);
	2469	#define PERL_ARGS_ASSERT_MAGIC_SETUVAR \
	2470	assert(sv); assert(mg)
	2471
	2472	PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV* sv, MAGIC* mg)
	2473	__attribute__nonnull__(pTHX_1)
	2474	__attribute__nonnull__(pTHX_2);
	2475	#define PERL_ARGS_ASSERT_MAGIC_SETVEC \
	2476	assert(sv); assert(mg)
	2477
	2478	PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV* sv, MAGIC* mg)
	2479	__attribute__nonnull__(pTHX_1)
	2480	__attribute__nonnull__(pTHX_2);
	2481	#define PERL_ARGS_ASSERT_MAGIC_SIZEPACK \
	2482	assert(sv); assert(mg)
	2483
	2484	PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV* sv, MAGIC* mg)
	2485	__attribute__nonnull__(pTHX_1)
	2486	__attribute__nonnull__(pTHX_2);
	2487	#define PERL_ARGS_ASSERT_MAGIC_WIPEPACK \
	2488	assert(sv); assert(mg)
	2489
	2490	PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes)
	2491	__attribute__malloc__
	2492	__attribute__warn_unused_result__;
	2493
	2494	PERL_CALLCONV void Perl_markstack_grow(pTHX);
	2495	PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...)
	2496	__attribute__format__(__printf__,pTHX_1,pTHX_2)
	2497	__attribute__nonnull__(pTHX_1);
	2498	#define PERL_ARGS_ASSERT_MESS \
	2499	assert(pat)
	2500
	2501	PERL_CALLCONV SV* Perl_mess_sv(pTHX_ SV* basemsg, bool consume)
	2502	__attribute__nonnull__(pTHX_1);
	2503	#define PERL_ARGS_ASSERT_MESS_SV \
	2504	assert(basemsg)
	2505
	2506	PERL_CALLCONV Free_t Perl_mfree(Malloc_t where);
	2507	PERL_CALLCONV int Perl_mg_clear(pTHX_ SV* sv)
	2508	__attribute__nonnull__(pTHX_1);
	2509	#define PERL_ARGS_ASSERT_MG_CLEAR \
	2510	assert(sv)
	2511
	2512	PERL_CALLCONV int Perl_mg_copy(pTHX_ SV sv, SV nsv, const char *key, I32 klen)
	2513	__attribute__nonnull__(pTHX_1)
	2514	__attribute__nonnull__(pTHX_2);
	2515	#define PERL_ARGS_ASSERT_MG_COPY \
	2516	assert(sv); assert(nsv)
	2517
	2518	PERL_CALLCONV MAGIC* Perl_mg_find(pTHX_ const SV* sv, int type)
	2519	__attribute__warn_unused_result__;
	2520
	2521	PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv)
	2522	__attribute__warn_unused_result__
	2523	__attribute__nonnull__(pTHX_1);
	2524	#define PERL_ARGS_ASSERT_MG_FIND_MGLOB \
	2525	assert(sv)
	2526
	2527	PERL_CALLCONV MAGIC* Perl_mg_findext(pTHX_ const SV* sv, int type, const MGVTBL *vtbl)
	2528	__attribute__warn_unused_result__;
	2529
	2530	PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv)
	2531	__attribute__nonnull__(pTHX_1);
	2532	#define PERL_ARGS_ASSERT_MG_FREE \
	2533	assert(sv)
	2534
	2535	PERL_CALLCONV void Perl_mg_free_type(pTHX_ SV* sv, int how)
	2536	__attribute__nonnull__(pTHX_1);
	2537	#define PERL_ARGS_ASSERT_MG_FREE_TYPE \
	2538	assert(sv)
	2539
	2540	PERL_CALLCONV int Perl_mg_get(pTHX_ SV* sv)
	2541	__attribute__nonnull__(pTHX_1);
	2542	#define PERL_ARGS_ASSERT_MG_GET \
	2543	assert(sv)
	2544
	2545	PERL_CALLCONV U32 Perl_mg_length(pTHX_ SV* sv)
	2546	__attribute__deprecated__
	2547	__attribute__nonnull__(pTHX_1);
	2548	#define PERL_ARGS_ASSERT_MG_LENGTH \
	2549	assert(sv)
	2550
	2551	PERL_CALLCONV void Perl_mg_localize(pTHX_ SV* sv, SV* nsv, bool setmagic)
	2552	__attribute__nonnull__(pTHX_1)
	2553	__attribute__nonnull__(pTHX_2);
	2554	#define PERL_ARGS_ASSERT_MG_LOCALIZE \
	2555	assert(sv); assert(nsv)
	2556
	2557	PERL_CALLCONV void Perl_mg_magical(pTHX_ SV* sv)
	2558	__attribute__nonnull__(pTHX_1);
	2559	#define PERL_ARGS_ASSERT_MG_MAGICAL \
	2560	assert(sv)
	2561
	2562	PERL_CALLCONV int Perl_mg_set(pTHX_ SV* sv)
	2563	__attribute__nonnull__(pTHX_1);
	2564	#define PERL_ARGS_ASSERT_MG_SET \
	2565	assert(sv)
	2566
	2567	PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV* sv)
	2568	__attribute__nonnull__(pTHX_1);
	2569	#define PERL_ARGS_ASSERT_MG_SIZE \
	2570	assert(sv)
	2571
	2572	PERL_CALLCONV void Perl_mini_mktime(pTHX_ struct tm *ptm)
	2573	__attribute__nonnull__(pTHX_1);
	2574	#define PERL_ARGS_ASSERT_MINI_MKTIME \
	2575	assert(ptm)
	2576
	2577	PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len);
	2578	PERL_CALLCONV void * Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size);
	2579	PERL_CALLCONV const char* Perl_moreswitches(pTHX_ const char* s)
	2580	__attribute__nonnull__(pTHX_1);
	2581	#define PERL_ARGS_ASSERT_MORESWITCHES \
	2582	assert(s)
	2583
	2584	PERL_CALLCONV const struct mro_alg * Perl_mro_get_from_name(pTHX_ SV *name)
	2585	__attribute__nonnull__(pTHX_1);
	2586	#define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \
	2587	assert(name)
	2588
	2589	PERL_CALLCONV AV* Perl_mro_get_linear_isa(pTHX_ HV* stash)
	2590	__attribute__nonnull__(pTHX_1);
	2591	#define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \
	2592	assert(stash)
	2593
	2594	PERL_CALLCONV SV* Perl_mro_get_private_data(pTHX_ struct mro_meta const smeta, const struct mro_alg const which)
	2595	__attribute__nonnull__(pTHX_1)
	2596	__attribute__nonnull__(pTHX_2);
	2597	#define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \
	2598	assert(smeta); assert(which)
	2599
	2600	PERL_CALLCONV void Perl_mro_isa_changed_in(pTHX_ HV* stash)
	2601	__attribute__nonnull__(pTHX_1);
	2602	#define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \
	2603	assert(stash)
	2604
	2605	PERL_CALLCONV struct mro_meta* Perl_mro_meta_init(pTHX_ HV* stash)
	2606	__attribute__nonnull__(pTHX_1);
	2607	#define PERL_ARGS_ASSERT_MRO_META_INIT \
	2608	assert(stash)
	2609
	2610	PERL_CALLCONV void Perl_mro_method_changed_in(pTHX_ HV* stash)
	2611	__attribute__nonnull__(pTHX_1);
	2612	#define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \
	2613	assert(stash)
	2614
	2615	PERL_CALLCONV void Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags)
	2616	__attribute__nonnull__(pTHX_3);
	2617	#define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED \
	2618	assert(gv)
	2619
	2620	PERL_CALLCONV void Perl_mro_register(pTHX_ const struct mro_alg *mro)
	2621	__attribute__nonnull__(pTHX_1);
	2622	#define PERL_ARGS_ASSERT_MRO_REGISTER \
	2623	assert(mro)
	2624
	2625	PERL_CALLCONV void Perl_mro_set_mro(pTHX_ struct mro_meta const meta, SV const name)
	2626	__attribute__nonnull__(pTHX_1)
	2627	__attribute__nonnull__(pTHX_2);
	2628	#define PERL_ARGS_ASSERT_MRO_SET_MRO \
	2629	assert(meta); assert(name)
	2630
	2631	PERL_CALLCONV SV* Perl_mro_set_private_data(pTHX_ struct mro_meta const smeta, const struct mro_alg const which, SV *const data)
	2632	__attribute__nonnull__(pTHX_1)
	2633	__attribute__nonnull__(pTHX_2)
	2634	__attribute__nonnull__(pTHX_3);
	2635	#define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \
	2636	assert(smeta); assert(which); assert(data)
	2637
	2638	PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s)
	2639	__attribute__nonnull__(pTHX_1);
	2640	#define PERL_ARGS_ASSERT_MY_ATOF \
	2641	assert(s)
	2642
	2643	PERL_CALLCONV char* Perl_my_atof2(pTHX_ const char s, NV value)
	2644	__attribute__nonnull__(pTHX_1)
	2645	__attribute__nonnull__(pTHX_2);
	2646	#define PERL_ARGS_ASSERT_MY_ATOF2 \
	2647	assert(s); assert(value)
	2648
	2649	PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP o, OP attrs)
	2650	__attribute__nonnull__(pTHX_1);
	2651	#define PERL_ARGS_ASSERT_MY_ATTRS \
	2652	assert(o)
	2653
	2654	PERL_CALLCONV void Perl_my_clearenv(pTHX);
	2655	PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir);
	2656	PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status)
	2657	__attribute__noreturn__;
	2658
	2659	PERL_CALLCONV_NO_RET void Perl_my_failure_exit(pTHX)
	2660	__attribute__noreturn__;
	2661
	2662	PERL_CALLCONV I32 Perl_my_fflush_all(pTHX);
	2663	PERL_CALLCONV Pid_t Perl_my_fork(void);
	2664	/* PERL_CALLCONV I32 Perl_my_lstat(pTHX); */
	2665	PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags);
	2666	PERL_CALLCONV PerlIO* Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** args)
	2667	__attribute__nonnull__(pTHX_1)
	2668	__attribute__nonnull__(pTHX_3);
	2669	#define PERL_ARGS_ASSERT_MY_POPEN_LIST \
	2670	assert(mode); assert(args)
	2671
	2672	PERL_CALLCONV void Perl_my_setenv(pTHX_ const char* nam, const char* val);
	2673	PERL_CALLCONV int Perl_my_snprintf(char buffer, const Size_t len, const char format, ...)
	2674	__attribute__format__(__printf__,3,4)
	2675	__attribute__nonnull__(1)
	2676	__attribute__nonnull__(3);
	2677	#define PERL_ARGS_ASSERT_MY_SNPRINTF \
	2678	assert(buffer); assert(format)
	2679
	2680	PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]);
	2681	/* PERL_CALLCONV I32 Perl_my_stat(pTHX); */
	2682	PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags);
	2683	PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
	2684	__attribute__format__(__strftime__,pTHX_1,0)
	2685	__attribute__nonnull__(pTHX_1);
	2686	#define PERL_ARGS_ASSERT_MY_STRFTIME \
	2687	assert(fmt)
	2688
	2689	PERL_CALLCONV void Perl_my_unexec(pTHX);
	2690	PERL_CALLCONV int Perl_my_vsnprintf(char buffer, const Size_t len, const char format, va_list ap)
	2691	__attribute__nonnull__(1)
	2692	__attribute__nonnull__(3);
	2693	#define PERL_ARGS_ASSERT_MY_VSNPRINTF \
	2694	assert(buffer); assert(format)
	2695
	2696	PERL_CALLCONV OP* Perl_newANONATTRSUB(pTHX_ I32 floor, OP proto, OP attrs, OP *block);
	2697	PERL_CALLCONV OP* Perl_newANONHASH(pTHX_ OP* o)
	2698	__attribute__malloc__
	2699	__attribute__warn_unused_result__;
	2700
	2701	PERL_CALLCONV OP* Perl_newANONLIST(pTHX_ OP* o)
	2702	__attribute__malloc__
	2703	__attribute__warn_unused_result__;
	2704
	2705	PERL_CALLCONV OP* Perl_newANONSUB(pTHX_ I32 floor, OP* proto, OP* block);
	2706	PERL_CALLCONV OP* Perl_newASSIGNOP(pTHX_ I32 flags, OP* left, I32 optype, OP* right)
	2707	__attribute__malloc__
	2708	__attribute__warn_unused_result__;
	2709
	2710	/* PERL_CALLCONV CV* newATTRSUB(pTHX_ I32 floor, OP o, OP proto, OP attrs, OP block); */
	2711	PERL_CALLCONV CV* Perl_newATTRSUB_x(pTHX_ I32 floor, OP o, OP proto, OP attrs, OP block, bool o_is_gv);
	2712	/* PERL_CALLCONV AV* Perl_newAV(pTHX)
	2713	__attribute__warn_unused_result__; */
	2714
	2715	PERL_CALLCONV OP* Perl_newAVREF(pTHX_ OP* o)
	2716	__attribute__malloc__
	2717	__attribute__warn_unused_result__
	2718	__attribute__nonnull__(pTHX_1);
	2719	#define PERL_ARGS_ASSERT_NEWAVREF \
	2720	assert(o)
	2721
	2722	PERL_CALLCONV OP* Perl_newBINOP(pTHX_ I32 type, I32 flags, OP* first, OP* last)
	2723	__attribute__malloc__
	2724	__attribute__warn_unused_result__;
	2725
	2726	PERL_CALLCONV OP* Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* falseop)
	2727	__attribute__malloc__
	2728	__attribute__warn_unused_result__
	2729	__attribute__nonnull__(pTHX_2);
	2730	#define PERL_ARGS_ASSERT_NEWCONDOP \
	2731	assert(first)
	2732
	2733	PERL_CALLCONV CV* Perl_newCONSTSUB(pTHX_ HV* stash, const char* name, SV* sv);
	2734	PERL_CALLCONV CV* Perl_newCONSTSUB_flags(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags, SV* sv);
	2735	PERL_CALLCONV OP* Perl_newCVREF(pTHX_ I32 flags, OP* o)
	2736	__attribute__malloc__
	2737	__attribute__warn_unused_result__;
	2738
	2739	PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont)
	2740	__attribute__malloc__
	2741	__attribute__warn_unused_result__
	2742	__attribute__nonnull__(pTHX_3);
	2743	#define PERL_ARGS_ASSERT_NEWFOROP \
	2744	assert(expr)
	2745
	2746	PERL_CALLCONV OP* Perl_newGIVENOP(pTHX_ OP* cond, OP* block, PADOFFSET defsv_off)
	2747	__attribute__malloc__
	2748	__attribute__warn_unused_result__
	2749	__attribute__nonnull__(pTHX_1)
	2750	__attribute__nonnull__(pTHX_2);
	2751	#define PERL_ARGS_ASSERT_NEWGIVENOP \
	2752	assert(cond); assert(block)
	2753
	2754	PERL_CALLCONV GP * Perl_newGP(pTHX_ GV *const gv)
	2755	__attribute__nonnull__(pTHX_1);
	2756	#define PERL_ARGS_ASSERT_NEWGP \
	2757	assert(gv)
	2758
	2759	PERL_CALLCONV OP* Perl_newGVOP(pTHX_ I32 type, I32 flags, GV* gv)
	2760	__attribute__malloc__
	2761	__attribute__warn_unused_result__
	2762	__attribute__nonnull__(pTHX_3);
	2763	#define PERL_ARGS_ASSERT_NEWGVOP \
	2764	assert(gv)
	2765
	2766	PERL_CALLCONV OP* Perl_newGVREF(pTHX_ I32 type, OP* o)
	2767	__attribute__malloc__
	2768	__attribute__warn_unused_result__;
	2769
	2770	/* PERL_CALLCONV GV* newGVgen(pTHX_ const char* pack)
	2771	__attribute__nonnull__(pTHX_1); */
	2772
	2773	PERL_CALLCONV GV* Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags)
	2774	__attribute__malloc__
	2775	__attribute__warn_unused_result__
	2776	__attribute__nonnull__(pTHX_1);
	2777	#define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \
	2778	assert(pack)
	2779
	2780	/* PERL_CALLCONV HV* Perl_newHV(pTHX)
	2781	__attribute__warn_unused_result__; */
	2782
	2783	PERL_CALLCONV OP* Perl_newHVREF(pTHX_ OP* o)
	2784	__attribute__malloc__
	2785	__attribute__warn_unused_result__
	2786	__attribute__nonnull__(pTHX_1);
	2787	#define PERL_ARGS_ASSERT_NEWHVREF \
	2788	assert(o)
	2789
	2790	PERL_CALLCONV HV* Perl_newHVhv(pTHX_ HV *hv)
	2791	__attribute__malloc__
	2792	__attribute__warn_unused_result__;
	2793
	2794	/* PERL_CALLCONV IO* Perl_newIO(pTHX)
	2795	__attribute__malloc__
	2796	__attribute__warn_unused_result__; */
	2797
	2798	PERL_CALLCONV OP* Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last)
	2799	__attribute__malloc__
	2800	__attribute__warn_unused_result__;
	2801
	2802	PERL_CALLCONV OP* Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP first, OP other)
	2803	__attribute__malloc__
	2804	__attribute__warn_unused_result__
	2805	__attribute__nonnull__(pTHX_3)
	2806	__attribute__nonnull__(pTHX_4);
	2807	#define PERL_ARGS_ASSERT_NEWLOGOP \
	2808	assert(first); assert(other)
	2809
	2810	PERL_CALLCONV OP* Perl_newLOOPEX(pTHX_ I32 type, OP* label)
	2811	__attribute__malloc__
	2812	__attribute__warn_unused_result__
	2813	__attribute__nonnull__(pTHX_2);
	2814	#define PERL_ARGS_ASSERT_NEWLOOPEX \
	2815	assert(label)
	2816
	2817	PERL_CALLCONV OP* Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP* block)
	2818	__attribute__malloc__
	2819	__attribute__warn_unused_result__;
	2820
	2821	PERL_CALLCONV CV * Perl_newMYSUB(pTHX_ I32 floor, OP o, OP proto, OP attrs, OP block)
	2822	__attribute__nonnull__(pTHX_2);
	2823	#define PERL_ARGS_ASSERT_NEWMYSUB \
	2824	assert(o)
	2825
	2826	PERL_CALLCONV OP* Perl_newNULLLIST(pTHX)
	2827	__attribute__malloc__
	2828	__attribute__warn_unused_result__;
	2829
	2830	PERL_CALLCONV OP* Perl_newOP(pTHX_ I32 optype, I32 flags)
	2831	__attribute__malloc__
	2832	__attribute__warn_unused_result__;
	2833
	2834	PERL_CALLCONV OP* Perl_newPMOP(pTHX_ I32 type, I32 flags)
	2835	__attribute__malloc__
	2836	__attribute__warn_unused_result__;
	2837
	2838	PERL_CALLCONV void Perl_newPROG(pTHX_ OP* o)
	2839	__attribute__nonnull__(pTHX_1);
	2840	#define PERL_ARGS_ASSERT_NEWPROG \
	2841	assert(o)
	2842
	2843	PERL_CALLCONV OP* Perl_newPVOP(pTHX_ I32 type, I32 flags, char* pv)
	2844	__attribute__malloc__
	2845	__attribute__warn_unused_result__;
	2846
	2847	PERL_CALLCONV OP* Perl_newRANGE(pTHX_ I32 flags, OP* left, OP* right)
	2848	__attribute__malloc__
	2849	__attribute__warn_unused_result__
	2850	__attribute__nonnull__(pTHX_2)
	2851	__attribute__nonnull__(pTHX_3);
	2852	#define PERL_ARGS_ASSERT_NEWRANGE \
	2853	assert(left); assert(right)
	2854
	2855	PERL_CALLCONV SV* Perl_newRV(pTHX_ SV *const sv)
	2856	__attribute__malloc__
	2857	__attribute__warn_unused_result__
	2858	__attribute__nonnull__(pTHX_1);
	2859	#define PERL_ARGS_ASSERT_NEWRV \
	2860	assert(sv)
	2861
	2862	PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const sv)
	2863	__attribute__malloc__
	2864	__attribute__warn_unused_result__
	2865	__attribute__nonnull__(pTHX_1);
	2866	#define PERL_ARGS_ASSERT_NEWRV_NOINC \
	2867	assert(sv)
	2868
	2869	PERL_CALLCONV OP* Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop)
	2870	__attribute__malloc__
	2871	__attribute__warn_unused_result__;
	2872
	2873	PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o)
	2874	__attribute__malloc__
	2875	__attribute__warn_unused_result__;
	2876
	2877	PERL_CALLCONV CV* Perl_newSTUB(pTHX_ GV *gv, bool fake)
	2878	__attribute__nonnull__(pTHX_1);
	2879	#define PERL_ARGS_ASSERT_NEWSTUB \
	2880	assert(gv)
	2881
	2882	/* PERL_CALLCONV CV* Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); */
	2883	PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len)
	2884	__attribute__malloc__
	2885	__attribute__warn_unused_result__;
	2886
	2887	PERL_CALLCONV OP* Perl_newSVOP(pTHX_ I32 type, I32 flags, SV* sv)
	2888	__attribute__malloc__
	2889	__attribute__warn_unused_result__
	2890	__attribute__nonnull__(pTHX_3);
	2891	#define PERL_ARGS_ASSERT_NEWSVOP \
	2892	assert(sv)
	2893
	2894	PERL_CALLCONV OP* Perl_newSVREF(pTHX_ OP* o)
	2895	__attribute__malloc__
	2896	__attribute__warn_unused_result__
	2897	__attribute__nonnull__(pTHX_1);
	2898	#define PERL_ARGS_ASSERT_NEWSVREF \
	2899	assert(o)
	2900
	2901	PERL_CALLCONV SV* Perl_newSV_type(pTHX_ const svtype type)
	2902	__attribute__malloc__
	2903	__attribute__warn_unused_result__;
	2904
	2905	PERL_CALLCONV SV* Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible)
	2906	__attribute__malloc__
	2907	__attribute__warn_unused_result__
	2908	__attribute__nonnull__(pTHX_1);
	2909	#define PERL_ARGS_ASSERT_NEWSVAVDEFELEM \
	2910	assert(av)
	2911
	2912	PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *const hek)
	2913	__attribute__malloc__
	2914	__attribute__warn_unused_result__;
	2915
	2916	PERL_CALLCONV SV* Perl_newSViv(pTHX_ const IV i)
	2917	__attribute__malloc__
	2918	__attribute__warn_unused_result__;
	2919
	2920	PERL_CALLCONV SV* Perl_newSVnv(pTHX_ const NV n)
	2921	__attribute__malloc__
	2922	__attribute__warn_unused_result__;
	2923
	2924	PERL_CALLCONV SV* Perl_newSVpv(pTHX_ const char *const s, const STRLEN len)
	2925	__attribute__malloc__
	2926	__attribute__warn_unused_result__;
	2927
	2928	PERL_CALLCONV SV* Perl_newSVpv_share(pTHX_ const char* s, U32 hash)
	2929	__attribute__malloc__
	2930	__attribute__warn_unused_result__;
	2931
	2932	PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...)
	2933	__attribute__malloc__
	2934	__attribute__warn_unused_result__
	2935	__attribute__format__(__printf__,pTHX_1,pTHX_2)
	2936	__attribute__nonnull__(pTHX_1);
	2937	#define PERL_ARGS_ASSERT_NEWSVPVF \
	2938	assert(pat)
	2939
	2940	PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const s, const STRLEN len)
	2941	__attribute__malloc__
	2942	__attribute__warn_unused_result__;
	2943
	2944	PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags)
	2945	__attribute__malloc__
	2946	__attribute__warn_unused_result__;
	2947
	2948	PERL_CALLCONV SV* Perl_newSVpvn_share(pTHX_ const char* s, I32 len, U32 hash)
	2949	__attribute__malloc__
	2950	__attribute__warn_unused_result__;
	2951
	2952	PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV const rv, const char const classname)
	2953	__attribute__nonnull__(pTHX_1);
	2954	#define PERL_ARGS_ASSERT_NEWSVRV \
	2955	assert(rv)
	2956
	2957	PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV *const old)
	2958	__attribute__malloc__
	2959	__attribute__warn_unused_result__;
	2960
	2961	PERL_CALLCONV SV* Perl_newSVuv(pTHX_ const UV u)
	2962	__attribute__malloc__
	2963	__attribute__warn_unused_result__;
	2964
	2965	PERL_CALLCONV OP* Perl_newUNOP(pTHX_ I32 type, I32 flags, OP* first)
	2966	__attribute__malloc__
	2967	__attribute__warn_unused_result__;
	2968
	2969	PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block)
	2970	__attribute__malloc__
	2971	__attribute__warn_unused_result__
	2972	__attribute__nonnull__(pTHX_2);
	2973	#define PERL_ARGS_ASSERT_NEWWHENOP \
	2974	assert(block)
	2975
	2976	PERL_CALLCONV OP* Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, OP* expr, OP* block, OP* cont, I32 has_my)
	2977	__attribute__malloc__
	2978	__attribute__warn_unused_result__;
	2979
	2980	PERL_CALLCONV CV* Perl_newXS(pTHX_ const char name, XSUBADDR_t subaddr, const char filename)
	2981	__attribute__nonnull__(pTHX_2)
	2982	__attribute__nonnull__(pTHX_3);
	2983	#define PERL_ARGS_ASSERT_NEWXS \
	2984	assert(subaddr); assert(filename)
	2985
	2986	PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char name, XSUBADDR_t subaddr, const char const filename, const char *const proto, U32 flags)
	2987	__attribute__nonnull__(pTHX_2)
	2988	__attribute__nonnull__(pTHX_3);
	2989	#define PERL_ARGS_ASSERT_NEWXS_FLAGS \
	2990	assert(subaddr); assert(filename)
	2991
	2992	PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char name, STRLEN len, XSUBADDR_t subaddr, const char const filename, const char const proto, SV *const_svp, U32 flags)
	2993	__attribute__nonnull__(pTHX_3)
	2994	__attribute__nonnull__(pTHX_4);
	2995	#define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \
	2996	assert(subaddr); assert(filename)
	2997
	2998	PERL_CALLCONV void Perl_new_collate(pTHX_ const char* newcoll);
	2999	PERL_CALLCONV void Perl_new_ctype(pTHX_ const char* newctype)
	3000	__attribute__nonnull__(pTHX_1);
	3001	#define PERL_ARGS_ASSERT_NEW_CTYPE \
	3002	assert(newctype)
	3003
	3004	PERL_CALLCONV void Perl_new_numeric(pTHX_ const char* newcoll);
	3005	PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems)
	3006	__attribute__malloc__
	3007	__attribute__warn_unused_result__;
	3008
	3009	PERL_CALLCONV SV* Perl_new_version(pTHX_ SV *ver)
	3010	__attribute__nonnull__(pTHX_1);
	3011	#define PERL_ARGS_ASSERT_NEW_VERSION \
	3012	assert(ver)
	3013
	3014	PERL_CALLCONV STRLEN * Perl_new_warnings_bitfield(pTHX_ STRLEN buffer, const char const bits, STRLEN size)
	3015	__attribute__malloc__
	3016	__attribute__warn_unused_result__
	3017	__attribute__nonnull__(pTHX_2);
	3018	#define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD \
	3019	assert(bits)
	3020
	3021	PERL_CALLCONV PerlIO* Perl_nextargv(pTHX_ GV* gv)
	3022	__attribute__nonnull__(pTHX_1);
	3023	#define PERL_ARGS_ASSERT_NEXTARGV \
	3024	assert(gv)
	3025
	3026	PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend)
	3027	__attribute__pure__
	3028	__attribute__nonnull__(1)
	3029	__attribute__nonnull__(2)
	3030	__attribute__nonnull__(3)
	3031	__attribute__nonnull__(4);
	3032	#define PERL_ARGS_ASSERT_NINSTR \
	3033	assert(big); assert(bigend); assert(little); assert(lend)
	3034
	3035	PERL_CALLCONV int Perl_nothreadhook(pTHX);
	3036	PERL_CALLCONV OP* Perl_oopsAV(pTHX_ OP* o)
	3037	__attribute__warn_unused_result__
	3038	__attribute__nonnull__(pTHX_1);
	3039	#define PERL_ARGS_ASSERT_OOPSAV \
	3040	assert(o)
	3041
	3042	PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o)
	3043	__attribute__warn_unused_result__
	3044	__attribute__nonnull__(pTHX_1);
	3045	#define PERL_ARGS_ASSERT_OOPSHV \
	3046	assert(o)
	3047
	3048	PERL_CALLCONV OP* Perl_op_append_elem(pTHX_ I32 optype, OP* first, OP* last);
	3049	PERL_CALLCONV OP* Perl_op_append_list(pTHX_ I32 optype, OP* first, OP* last);
	3050	PERL_CALLCONV void Perl_op_clear(pTHX_ OP* o)
	3051	__attribute__nonnull__(pTHX_1);
	3052	#define PERL_ARGS_ASSERT_OP_CLEAR \
	3053	assert(o)
	3054
	3055	PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o)
	3056	__attribute__warn_unused_result__;
	3057
	3058	PERL_CALLCONV OP* Perl_op_contextualize(pTHX_ OP* o, I32 context)
	3059	__attribute__nonnull__(pTHX_1);
	3060	#define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \
	3061	assert(o)
	3062
	3063	PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o)
	3064	__attribute__nonnull__(pTHX_1);
	3065	#define PERL_ARGS_ASSERT_OP_DUMP \
	3066	assert(o)
	3067
	3068	PERL_CALLCONV void Perl_op_free(pTHX_ OP* arg);
	3069	PERL_CALLCONV OP* Perl_op_linklist(pTHX_ OP *o)
	3070	__attribute__nonnull__(pTHX_1);
	3071	#define PERL_ARGS_ASSERT_OP_LINKLIST \
	3072	assert(o)
	3073
	3074	/* PERL_CALLCONV OP* op_lvalue(pTHX_ OP* o, I32 type); */
	3075	PERL_CALLCONV OP* Perl_op_lvalue_flags(pTHX_ OP* o, I32 type, U32 flags);
	3076	PERL_CALLCONV void Perl_op_null(pTHX_ OP* o)
	3077	__attribute__nonnull__(pTHX_1);
	3078	#define PERL_ARGS_ASSERT_OP_NULL \
	3079	assert(o)
	3080
	3081	PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last);
	3082	PERL_CALLCONV void Perl_op_refcnt_lock(pTHX);
	3083	PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX);
	3084	PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o);
	3085	PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o);
	3086	PERL_CALLCONV void Perl_pack_cat(pTHX_ SV cat, const char pat, const char patend, SV beglist, SV endlist, SV **next_in_list, U32 flags)
	3087	__attribute__nonnull__(pTHX_1)
	3088	__attribute__nonnull__(pTHX_2)
	3089	__attribute__nonnull__(pTHX_3)
	3090	__attribute__nonnull__(pTHX_4)
	3091	__attribute__nonnull__(pTHX_5)
	3092	__attribute__nonnull__(pTHX_6);
	3093	#define PERL_ARGS_ASSERT_PACK_CAT \
	3094	assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list)
	3095
	3096	PERL_CALLCONV void Perl_package_version(pTHX_ OP* v)
	3097	__attribute__nonnull__(pTHX_1);
	3098	#define PERL_ARGS_ASSERT_PACKAGE_VERSION \
	3099	assert(v)
	3100
	3101	PERL_CALLCONV void Perl_packlist(pTHX_ SV cat, const char pat, const char patend, SV beglist, SV *endlist)
	3102	__attribute__nonnull__(pTHX_1)
	3103	__attribute__nonnull__(pTHX_2)
	3104	__attribute__nonnull__(pTHX_3)
	3105	__attribute__nonnull__(pTHX_4)
	3106	__attribute__nonnull__(pTHX_5);
	3107	#define PERL_ARGS_ASSERT_PACKLIST \
	3108	assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist)
	3109
	3110	PERL_CALLCONV PADOFFSET Perl_pad_add_anon(pTHX_ CV* func, I32 optype)
	3111	__attribute__nonnull__(pTHX_1);
	3112	#define PERL_ARGS_ASSERT_PAD_ADD_ANON \
	3113	assert(func)
	3114
	3115	PERL_CALLCONV PADOFFSET Perl_pad_add_name_pv(pTHX_ const char name, const U32 flags, HV typestash, HV *ourstash)
	3116	__attribute__nonnull__(pTHX_1);
	3117	#define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV \
	3118	assert(name)
	3119
	3120	PERL_CALLCONV PADOFFSET Perl_pad_add_name_pvn(pTHX_ const char namepv, STRLEN namelen, U32 flags, HV typestash, HV *ourstash)
	3121	__attribute__nonnull__(pTHX_1);
	3122	#define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN \
	3123	assert(namepv)
	3124
	3125	PERL_CALLCONV PADOFFSET Perl_pad_add_name_sv(pTHX_ SV name, U32 flags, HV typestash, HV *ourstash)
	3126	__attribute__nonnull__(pTHX_1);
	3127	#define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \
	3128	assert(name)
	3129
	3130	PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
	3131	PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full);
	3132	PERL_CALLCONV HV* Perl_pad_compname_type(pTHX_ const PADOFFSET po)
	3133	__attribute__warn_unused_result__;
	3134
	3135	PERL_CALLCONV PADOFFSET Perl_pad_findmy_pv(pTHX_ const char* name, U32 flags)
	3136	__attribute__nonnull__(pTHX_1);
	3137	#define PERL_ARGS_ASSERT_PAD_FINDMY_PV \
	3138	assert(name)
	3139
	3140	PERL_CALLCONV PADOFFSET Perl_pad_findmy_pvn(pTHX_ const char* namepv, STRLEN namelen, U32 flags)
	3141	__attribute__nonnull__(pTHX_1);
	3142	#define PERL_ARGS_ASSERT_PAD_FINDMY_PVN \
	3143	assert(namepv)
	3144
	3145	PERL_CALLCONV PADOFFSET Perl_pad_findmy_sv(pTHX_ SV* name, U32 flags)
	3146	__attribute__nonnull__(pTHX_1);
	3147	#define PERL_ARGS_ASSERT_PAD_FINDMY_SV \
	3148	assert(name)
	3149
	3150	PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST padlist, CV old_cv, CV *new_cv)
	3151	__attribute__nonnull__(pTHX_1)
	3152	__attribute__nonnull__(pTHX_2)
	3153	__attribute__nonnull__(pTHX_3);
	3154	#define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \
	3155	assert(padlist); assert(old_cv); assert(new_cv)
	3156
	3157	PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po);
	3158	PERL_CALLCONV OP * Perl_pad_leavemy(pTHX);
	3159	PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags)
	3160	__attribute__malloc__
	3161	__attribute__warn_unused_result__;
	3162
	3163	PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth)
	3164	__attribute__nonnull__(pTHX_1);
	3165	#define PERL_ARGS_ASSERT_PAD_PUSH \
	3166	assert(padlist)
	3167
	3168	PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust);
	3169	PERL_CALLCONV void Perl_pad_tidy(pTHX_ padtidy_type type);
	3170	PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST padlist, I32 key, PAD val)
	3171	__attribute__nonnull__(pTHX_1);
	3172	#define PERL_ARGS_ASSERT_PADLIST_STORE \
	3173	assert(padlist)
	3174
	3175	PERL_CALLCONV OP* Perl_parse_arithexpr(pTHX_ U32 flags);
	3176	PERL_CALLCONV OP* Perl_parse_barestmt(pTHX_ U32 flags);
	3177	PERL_CALLCONV OP* Perl_parse_block(pTHX_ U32 flags);
	3178	PERL_CALLCONV OP* Perl_parse_fullexpr(pTHX_ U32 flags);
	3179	PERL_CALLCONV OP* Perl_parse_fullstmt(pTHX_ U32 flags);
	3180	PERL_CALLCONV SV* Perl_parse_label(pTHX_ U32 flags);
	3181	PERL_CALLCONV OP* Perl_parse_listexpr(pTHX_ U32 flags);
	3182	PERL_CALLCONV OP* Perl_parse_stmtseq(pTHX_ U32 flags);
	3183	PERL_CALLCONV OP* Perl_parse_termexpr(pTHX_ U32 flags);
	3184	PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt)
	3185	__attribute__nonnull__(pTHX_1);
	3186	#define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \
	3187	assert(popt)
	3188
	3189	PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser)
	3190	__attribute__nonnull__(pTHX_1);
	3191	#define PERL_ARGS_ASSERT_PARSER_FREE \
	3192	assert(parser)
	3193
	3194	PERL_CALLCONV void Perl_peep(pTHX_ OP* o);
	3195	PERL_CALLCONV PerlInterpreter* perl_alloc(void);
	3196	PERL_CALLCONV void perl_construct(PerlInterpreter *my_perl)
	3197	__attribute__nonnull__(1);
	3198	#define PERL_ARGS_ASSERT_PERL_CONSTRUCT \
	3199	assert(my_perl)
	3200
	3201	PERL_CALLCONV int perl_destruct(PerlInterpreter *my_perl)
	3202	__attribute__nonnull__(1);
	3203	#define PERL_ARGS_ASSERT_PERL_DESTRUCT \
	3204	assert(my_perl)
	3205
	3206	PERL_CALLCONV void perl_free(PerlInterpreter *my_perl)
	3207	__attribute__nonnull__(1);
	3208	#define PERL_ARGS_ASSERT_PERL_FREE \
	3209	assert(my_perl)
	3210
	3211	PERL_CALLCONV int perl_parse(PerlInterpreter my_perl, XSINIT_t xsinit, int argc, char* argv, char** env)
	3212	__attribute__nonnull__(1);
	3213	#define PERL_ARGS_ASSERT_PERL_PARSE \
	3214	assert(my_perl)
	3215
	3216	PERL_CALLCONV int perl_run(PerlInterpreter *my_perl)
	3217	__attribute__nonnull__(1);
	3218	#define PERL_ARGS_ASSERT_PERL_RUN \
	3219	assert(my_perl)
	3220
	3221	PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm);
	3222	PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP o, OP expr, bool isreg, I32 floor)
	3223	__attribute__nonnull__(pTHX_1)
	3224	__attribute__nonnull__(pTHX_2);
	3225	#define PERL_ARGS_ASSERT_PMRUNTIME \
	3226	assert(o); assert(expr)
	3227
	3228	PERL_CALLCONV void Perl_pop_scope(pTHX);
	3229	PERL_CALLCONV void Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...)
	3230	__attribute__nonnull__(pTHX_1);
	3231	#define PERL_ARGS_ASSERT_POPULATE_ISA \
	3232	assert(name)
	3233
	3234	PERL_CALLCONV REGEXP* Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags)
	3235	__attribute__nonnull__(pTHX_1);
	3236	#define PERL_ARGS_ASSERT_PREGCOMP \
	3237	assert(pattern)
	3238
	3239	PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, SSize_t minend, SV* screamer, U32 nosave)
	3240	__attribute__nonnull__(pTHX_1)
	3241	__attribute__nonnull__(pTHX_2)
	3242	__attribute__nonnull__(pTHX_3)
	3243	__attribute__nonnull__(pTHX_4)
	3244	__attribute__nonnull__(pTHX_6);
	3245	#define PERL_ARGS_ASSERT_PREGEXEC \
	3246	assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer)
	3247
	3248	PERL_CALLCONV void Perl_pregfree(pTHX_ REGEXP* r);
	3249	PERL_CALLCONV void Perl_pregfree2(pTHX_ REGEXP *rx)
	3250	__attribute__nonnull__(pTHX_1);
	3251	#define PERL_ARGS_ASSERT_PREGFREE2 \
	3252	assert(rx)
	3253
	3254	PERL_CALLCONV const char* Perl_prescan_version(pTHX_ const char s, bool strict, const char* errstr, bool sqv, int ssaw_decimal, int swidth, bool salpha)
	3255	__attribute__nonnull__(pTHX_1);
	3256	#define PERL_ARGS_ASSERT_PRESCAN_VERSION \
	3257	assert(s)
	3258
	3259	PERL_CALLCONV void Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl)
	3260	__attribute__deprecated__;
	3261
	3262	PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t const tbl, const void const sv)
	3263	__attribute__warn_unused_result__
	3264	__attribute__nonnull__(pTHX_1);
	3265	#define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \
	3266	assert(tbl)
	3267
	3268	PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl);
	3269	PERL_CALLCONV PTR_TBL_t* Perl_ptr_table_new(pTHX)
	3270	__attribute__malloc__
	3271	__attribute__warn_unused_result__;
	3272
	3273	PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl)
	3274	__attribute__nonnull__(pTHX_1);
	3275	#define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \
	3276	assert(tbl)
	3277
	3278	PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t const tbl, const void const oldsv, void *const newsv)
	3279	__attribute__nonnull__(pTHX_1)
	3280	__attribute__nonnull__(pTHX_3);
	3281	#define PERL_ARGS_ASSERT_PTR_TABLE_STORE \
	3282	assert(tbl); assert(newsv)
	3283
	3284	PERL_CALLCONV void Perl_push_scope(pTHX);
	3285	PERL_CALLCONV char* Perl_pv_display(pTHX_ SV dsv, const char pv, STRLEN cur, STRLEN len, STRLEN pvlim)
	3286	__attribute__nonnull__(pTHX_1)
	3287	__attribute__nonnull__(pTHX_2);
	3288	#define PERL_ARGS_ASSERT_PV_DISPLAY \
	3289	assert(dsv); assert(pv)
	3290
	3291	PERL_CALLCONV char* Perl_pv_escape(pTHX_ SV dsv, char const const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)
	3292	__attribute__nonnull__(pTHX_1)
	3293	__attribute__nonnull__(pTHX_2);
	3294	#define PERL_ARGS_ASSERT_PV_ESCAPE \
	3295	assert(dsv); assert(str)
	3296
	3297	PERL_CALLCONV char* Perl_pv_pretty(pTHX_ SV dsv, char const const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)
	3298	__attribute__nonnull__(pTHX_1)
	3299	__attribute__nonnull__(pTHX_2);
	3300	#define PERL_ARGS_ASSERT_PV_PRETTY \
	3301	assert(dsv); assert(str)
	3302
	3303	PERL_CALLCONV char* Perl_pv_uni_display(pTHX_ SV dsv, const U8 spv, STRLEN len, STRLEN pvlim, UV flags)
	3304	__attribute__nonnull__(pTHX_1)
	3305	__attribute__nonnull__(pTHX_2);
	3306	#define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \
	3307	assert(dsv); assert(spv)
	3308
	3309	PERL_CALLCONV void Perl_qerror(pTHX_ SV* err)
	3310	__attribute__nonnull__(pTHX_1);
	3311	#define PERL_ARGS_ASSERT_QERROR \
	3312	assert(err)
	3313
	3314	PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags)
	3315	__attribute__nonnull__(pTHX_1);
	3316	#define PERL_ARGS_ASSERT_RE_COMPILE \
	3317	assert(pattern)
	3318
	3319	PERL_CALLCONV char* Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, const char* const strbeg, char* strpos, char* strend, const U32 flags, re_scream_pos_data *data)
	3320	__attribute__nonnull__(pTHX_1)
	3321	__attribute__nonnull__(pTHX_3)
	3322	__attribute__nonnull__(pTHX_4)
	3323	__attribute__nonnull__(pTHX_5);
	3324	#define PERL_ARGS_ASSERT_RE_INTUIT_START \
	3325	assert(rx); assert(strbeg); assert(strpos); assert(strend)
	3326
	3327	PERL_CALLCONV SV* Perl_re_intuit_string(pTHX_ REGEXP *const r)
	3328	__attribute__nonnull__(pTHX_1);
	3329	#define PERL_ARGS_ASSERT_RE_INTUIT_STRING \
	3330	assert(r)
	3331
	3332	PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP expr, const regexp_engine eng, REGEXP old_re, bool is_bare_re, U32 rx_flags, U32 pm_flags)
	3333	__attribute__nonnull__(pTHX_4);
	3334	#define PERL_ARGS_ASSERT_RE_OP_COMPILE \
	3335	assert(eng)
	3336
	3337	PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes)
	3338	__attribute__malloc__
	3339	__attribute__warn_unused_result__;
	3340
	3341	PERL_CALLCONV void Perl_reentrant_free(pTHX);
	3342	PERL_CALLCONV void Perl_reentrant_init(pTHX);
	3343	PERL_CALLCONV void* Perl_reentrant_retry(const char *f, ...)
	3344	__attribute__nonnull__(1);
	3345	#define PERL_ARGS_ASSERT_REENTRANT_RETRY \
	3346	assert(f)
	3347
	3348	PERL_CALLCONV void Perl_reentrant_size(pTHX);
	3349	/* PERL_CALLCONV OP* Perl_ref(pTHX_ OP* o, I32 type); */
	3350	PERL_CALLCONV HV * Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags);
	3351	PERL_CALLCONV SV * Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he chain, const char key, U32 hash, U32 flags)
	3352	__attribute__nonnull__(pTHX_2);
	3353	#define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \
	3354	assert(key)
	3355
	3356	PERL_CALLCONV SV * Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he chain, const char keypv, STRLEN keylen, U32 hash, U32 flags)
	3357	__attribute__nonnull__(pTHX_2);
	3358	#define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \
	3359	assert(keypv)
	3360
	3361	PERL_CALLCONV SV * Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he chain, SV key, U32 hash, U32 flags)
	3362	__attribute__nonnull__(pTHX_2);
	3363	#define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \
	3364	assert(key)
	3365
	3366	PERL_CALLCONV void Perl_refcounted_he_free(pTHX_ struct refcounted_he *he);
	3367	PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he);
	3368	PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he parent, const char key, U32 hash, SV *value, U32 flags)
	3369	__attribute__nonnull__(pTHX_2);
	3370	#define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \
	3371	assert(key)
	3372
	3373	PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he parent, const char keypv, STRLEN keylen, U32 hash, SV *value, U32 flags)
	3374	__attribute__nonnull__(pTHX_2);
	3375	#define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN \
	3376	assert(keypv)
	3377
	3378	PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he parent, SV key, U32 hash, SV *value, U32 flags)
	3379	__attribute__nonnull__(pTHX_2);
	3380	#define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV \
	3381	assert(key)
	3382
	3383	PERL_CALLCONV SV* Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags)
	3384	__attribute__nonnull__(pTHX_1);
	3385	#define PERL_ARGS_ASSERT_REG_NAMED_BUFF \
	3386	assert(rx)
	3387
	3388	PERL_CALLCONV SV* Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags)
	3389	__attribute__nonnull__(pTHX_1);
	3390	#define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \
	3391	assert(rx)
	3392
	3393	PERL_CALLCONV bool Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags)
	3394	__attribute__nonnull__(pTHX_1)
	3395	__attribute__nonnull__(pTHX_2);
	3396	#define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \
	3397	assert(rx); assert(key)
	3398
	3399	PERL_CALLCONV SV* Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags)
	3400	__attribute__nonnull__(pTHX_1)
	3401	__attribute__nonnull__(pTHX_2);
	3402	#define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \
	3403	assert(rx); assert(namesv)
	3404
	3405	PERL_CALLCONV SV* Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags)
	3406	__attribute__nonnull__(pTHX_1);
	3407	#define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \
	3408	assert(rx)
	3409
	3410	PERL_CALLCONV SV* Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags)
	3411	__attribute__nonnull__(pTHX_1);
	3412	#define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER \
	3413	assert(rx)
	3414
	3415	PERL_CALLCONV SV* Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags)
	3416	__attribute__nonnull__(pTHX_1);
	3417	#define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \
	3418	assert(rx)
	3419
	3420	PERL_CALLCONV SV* Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags)
	3421	__attribute__nonnull__(pTHX_1);
	3422	#define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \
	3423	assert(rx)
	3424
	3425	PERL_CALLCONV void Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const rx, const I32 paren, SV * const sv)
	3426	__attribute__nonnull__(pTHX_1);
	3427	#define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH \
	3428	assert(rx)
	3429
	3430	PERL_CALLCONV I32 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren)
	3431	__attribute__nonnull__(pTHX_1)
	3432	__attribute__nonnull__(pTHX_2);
	3433	#define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH \
	3434	assert(rx); assert(sv)
	3435
	3436	PERL_CALLCONV void Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value)
	3437	__attribute__nonnull__(pTHX_1);
	3438	#define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE \
	3439	assert(rx)
	3440
	3441	PERL_CALLCONV SV* Perl_reg_qr_package(pTHX_ REGEXP * const rx)
	3442	__attribute__nonnull__(pTHX_1);
	3443	#define PERL_ARGS_ASSERT_REG_QR_PACKAGE \
	3444	assert(rx)
	3445
	3446	PERL_CALLCONV REGEXP* Perl_reg_temp_copy(pTHX_ REGEXP* ret_x, REGEXP* rx)
	3447	__attribute__nonnull__(pTHX_2);
	3448	#define PERL_ARGS_ASSERT_REG_TEMP_COPY \
	3449	assert(rx)
	3450
	3451	PERL_CALLCONV SV* Perl_regclass_swash(pTHX_ const regexp prog, const struct regnode node, bool doinit, SV listsvp, SV altsvp)
	3452	__attribute__nonnull__(pTHX_2);
	3453	#define PERL_ARGS_ASSERT_REGCLASS_SWASH \
	3454	assert(node)
	3455
	3456	PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r)
	3457	__attribute__nonnull__(pTHX_1);
	3458	#define PERL_ARGS_ASSERT_REGDUMP \
	3459	assert(r)
	3460
	3461	PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP const rx, char stringarg, char strend, char strbeg, SSize_t minend, SV sv, void data, U32 flags)
	3462	__attribute__nonnull__(pTHX_1)
	3463	__attribute__nonnull__(pTHX_2)
	3464	__attribute__nonnull__(pTHX_3)
	3465	__attribute__nonnull__(pTHX_4)
	3466	__attribute__nonnull__(pTHX_6);
	3467	#define PERL_ARGS_ASSERT_REGEXEC_FLAGS \
	3468	assert(rx); assert(stringarg); assert(strend); assert(strbeg); assert(sv)
	3469
	3470	PERL_CALLCONV void Perl_regfree_internal(pTHX_ REGEXP *const rx)
	3471	__attribute__nonnull__(pTHX_1);
	3472	#define PERL_ARGS_ASSERT_REGFREE_INTERNAL \
	3473	assert(rx)
	3474
	3475	PERL_CALLCONV void Perl_reginitcolors(pTHX);
	3476	PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p)
	3477	__attribute__warn_unused_result__;
	3478
	3479	PERL_CALLCONV void Perl_regprop(pTHX_ const regexp prog, SV sv, const regnode* o)
	3480	__attribute__nonnull__(pTHX_2)
	3481	__attribute__nonnull__(pTHX_3);
	3482	#define PERL_ARGS_ASSERT_REGPROP \
	3483	assert(sv); assert(o)
	3484
	3485	PERL_CALLCONV void Perl_repeatcpy(char* to, const char* from, I32 len, IV count)
	3486	__attribute__nonnull__(1)
	3487	__attribute__nonnull__(2);
	3488	#define PERL_ARGS_ASSERT_REPEATCPY \
	3489	assert(to); assert(from)
	3490
	3491	PERL_CALLCONV void Perl_report_evil_fh(pTHX_ const GV *gv);
	3492	PERL_CALLCONV void Perl_report_uninit(pTHX_ const SV *uninit_sv);
	3493	PERL_CALLCONV void Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have);
	3494	PERL_CALLCONV void Perl_require_pv(pTHX_ const char* pv)
	3495	__attribute__nonnull__(pTHX_1);
	3496	#define PERL_ARGS_ASSERT_REQUIRE_PV \
	3497	assert(pv)
	3498
	3499	PERL_CALLCONV char* Perl_rninstr(const char* big, const char* bigend, const char* little, const char* lend)
	3500	__attribute__pure__
	3501	__attribute__nonnull__(1)
	3502	__attribute__nonnull__(2)
	3503	__attribute__nonnull__(3)
	3504	__attribute__nonnull__(4);
	3505	#define PERL_ARGS_ASSERT_RNINSTR \
	3506	assert(big); assert(bigend); assert(little); assert(lend)
	3507
	3508	PERL_CALLCONV void Perl_rpeep(pTHX_ OP* o);
	3509	PERL_CALLCONV Sighandler_t Perl_rsignal(pTHX_ int i, Sighandler_t t);
	3510	PERL_CALLCONV int Perl_rsignal_restore(pTHX_ int i, Sigsave_t* t);
	3511	PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t* save)
	3512	__attribute__nonnull__(pTHX_3);
	3513	#define PERL_ARGS_ASSERT_RSIGNAL_SAVE \
	3514	assert(save)
	3515
	3516	PERL_CALLCONV Sighandler_t Perl_rsignal_state(pTHX_ int i);
	3517	PERL_CALLCONV int Perl_runops_debug(pTHX);
	3518	PERL_CALLCONV int Perl_runops_standard(pTHX);
	3519	PERL_CALLCONV CV* Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags)
	3520	__attribute__nonnull__(pTHX_1);
	3521	#define PERL_ARGS_ASSERT_RV2CV_OP_CV \
	3522	assert(cvop)
	3523
	3524	PERL_CALLCONV void Perl_rxres_save(pTHX_ void *rsp, REGEXP rx)
	3525	__attribute__nonnull__(pTHX_1)
	3526	__attribute__nonnull__(pTHX_2);
	3527	#define PERL_ARGS_ASSERT_RXRES_SAVE \
	3528	assert(rsp); assert(rx)
	3529
	3530	PERL_CALLCONV Malloc_t Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size)
	3531	__attribute__malloc__
	3532	__attribute__warn_unused_result__;
	3533
	3534	PERL_CALLCONV Free_t Perl_safesysfree(Malloc_t where);
	3535	PERL_CALLCONV Malloc_t Perl_safesysmalloc(MEM_SIZE nbytes)
	3536	__attribute__malloc__
	3537	__attribute__warn_unused_result__;
	3538
	3539	PERL_CALLCONV Malloc_t Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes)
	3540	__attribute__malloc__
	3541	__attribute__warn_unused_result__;
	3542
	3543	PERL_CALLCONV void Perl_save_I16(pTHX_ I16* intp)
	3544	__attribute__nonnull__(pTHX_1);
	3545	#define PERL_ARGS_ASSERT_SAVE_I16 \
	3546	assert(intp)
	3547
	3548	PERL_CALLCONV void Perl_save_I32(pTHX_ I32* intp)
	3549	__attribute__nonnull__(pTHX_1);
	3550	#define PERL_ARGS_ASSERT_SAVE_I32 \
	3551	assert(intp)
	3552
	3553	PERL_CALLCONV void Perl_save_I8(pTHX_ I8* bytep)
	3554	__attribute__nonnull__(pTHX_1);
	3555	#define PERL_ARGS_ASSERT_SAVE_I8 \
	3556	assert(bytep)
	3557
	3558	PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, SSize_t key)
	3559	__attribute__nonnull__(pTHX_1);
	3560	#define PERL_ARGS_ASSERT_SAVE_ADELETE \
	3561	assert(av)
	3562
	3563	/* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr)
	3564	__attribute__nonnull__(pTHX_1)
	3565	__attribute__nonnull__(pTHX_3); */
	3566
	3567	PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, SSize_t idx, SV **sptr, const U32 flags)
	3568	__attribute__nonnull__(pTHX_1)
	3569	__attribute__nonnull__(pTHX_3);
	3570	#define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \
	3571	assert(av); assert(sptr)
	3572
	3573	PERL_CALLCONV I32 Perl_save_alloc(pTHX_ I32 size, I32 pad);
	3574	PERL_CALLCONV void Perl_save_aptr(pTHX_ AV** aptr)
	3575	__attribute__nonnull__(pTHX_1);
	3576	#define PERL_ARGS_ASSERT_SAVE_APTR \
	3577	assert(aptr)
	3578
	3579	PERL_CALLCONV AV* Perl_save_ary(pTHX_ GV* gv)
	3580	__attribute__nonnull__(pTHX_1);
	3581	#define PERL_ARGS_ASSERT_SAVE_ARY \
	3582	assert(gv)
	3583
	3584	PERL_CALLCONV void Perl_save_bool(pTHX_ bool* boolp)
	3585	__attribute__nonnull__(pTHX_1);
	3586	#define PERL_ARGS_ASSERT_SAVE_BOOL \
	3587	assert(boolp)
	3588
	3589	PERL_CALLCONV void Perl_save_clearsv(pTHX_ SV** svp)
	3590	__attribute__nonnull__(pTHX_1);
	3591	#define PERL_ARGS_ASSERT_SAVE_CLEARSV \
	3592	assert(svp)
	3593
	3594	PERL_CALLCONV void Perl_save_delete(pTHX_ HV hv, char key, I32 klen)
	3595	__attribute__nonnull__(pTHX_1)
	3596	__attribute__nonnull__(pTHX_2);
	3597	#define PERL_ARGS_ASSERT_SAVE_DELETE \
	3598	assert(hv); assert(key)
	3599
	3600	PERL_CALLCONV void Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p)
	3601	__attribute__nonnull__(pTHX_2);
	3602	#define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \
	3603	assert(p)
	3604
	3605	PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p);
	3606	/* PERL_CALLCONV void Perl_save_freeop(pTHX_ OP* o); */
	3607	/* PERL_CALLCONV void Perl_save_freepv(pTHX_ char* pv); */
	3608	/* PERL_CALLCONV void Perl_save_freesv(pTHX_ SV* sv); */
	3609	PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char** str)
	3610	__attribute__nonnull__(pTHX_1);
	3611	#define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \
	3612	assert(str)
	3613
	3614	PERL_CALLCONV void Perl_save_generic_svref(pTHX_ SV** sptr)
	3615	__attribute__nonnull__(pTHX_1);
	3616	#define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \
	3617	assert(sptr)
	3618
	3619	PERL_CALLCONV void Perl_save_gp(pTHX_ GV* gv, I32 empty)
	3620	__attribute__nonnull__(pTHX_1);
	3621	#define PERL_ARGS_ASSERT_SAVE_GP \
	3622	assert(gv)
	3623
	3624	PERL_CALLCONV HV* Perl_save_hash(pTHX_ GV* gv)
	3625	__attribute__nonnull__(pTHX_1);
	3626	#define PERL_ARGS_ASSERT_SAVE_HASH \
	3627	assert(gv)
	3628
	3629	PERL_CALLCONV void Perl_save_hdelete(pTHX_ HV hv, SV keysv)
	3630	__attribute__nonnull__(pTHX_1)
	3631	__attribute__nonnull__(pTHX_2);
	3632	#define PERL_ARGS_ASSERT_SAVE_HDELETE \
	3633	assert(hv); assert(keysv)
	3634
	3635	/* PERL_CALLCONV void Perl_save_helem(pTHX_ HV hv, SV key, SV **sptr)
	3636	__attribute__nonnull__(pTHX_1)
	3637	__attribute__nonnull__(pTHX_2)
	3638	__attribute__nonnull__(pTHX_3); */
	3639
	3640	PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV hv, SV key, SV **sptr, const U32 flags)
	3641	__attribute__nonnull__(pTHX_1)
	3642	__attribute__nonnull__(pTHX_2)
	3643	__attribute__nonnull__(pTHX_3);
	3644	#define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \
	3645	assert(hv); assert(key); assert(sptr)
	3646
	3647	PERL_CALLCONV void Perl_save_hints(pTHX);
	3648	PERL_CALLCONV void Perl_save_hptr(pTHX_ HV** hptr)
	3649	__attribute__nonnull__(pTHX_1);
	3650	#define PERL_ARGS_ASSERT_SAVE_HPTR \
	3651	assert(hptr)
	3652
	3653	PERL_CALLCONV void Perl_save_int(pTHX_ int* intp)
	3654	__attribute__nonnull__(pTHX_1);
	3655	#define PERL_ARGS_ASSERT_SAVE_INT \
	3656	assert(intp)
	3657
	3658	PERL_CALLCONV void Perl_save_item(pTHX_ SV* item)
	3659	__attribute__nonnull__(pTHX_1);
	3660	#define PERL_ARGS_ASSERT_SAVE_ITEM \
	3661	assert(item)
	3662
	3663	PERL_CALLCONV void Perl_save_iv(pTHX_ IV *ivp)
	3664	__attribute__nonnull__(pTHX_1);
	3665	#define PERL_ARGS_ASSERT_SAVE_IV \
	3666	assert(ivp)
	3667
	3668	PERL_CALLCONV void Perl_save_list(pTHX_ SV** sarg, I32 maxsarg)
	3669	__attribute__nonnull__(pTHX_1);
	3670	#define PERL_ARGS_ASSERT_SAVE_LIST \
	3671	assert(sarg)
	3672
	3673	PERL_CALLCONV void Perl_save_long(pTHX_ long* longp)
	3674	__attribute__nonnull__(pTHX_1);
	3675	#define PERL_ARGS_ASSERT_SAVE_LONG \
	3676	assert(longp)
	3677
	3678	/* PERL_CALLCONV void Perl_save_mortalizesv(pTHX_ SV* sv)
	3679	__attribute__nonnull__(pTHX_1); */
	3680	#define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \
	3681	assert(sv)
	3682
	3683	PERL_CALLCONV void Perl_save_nogv(pTHX_ GV* gv)
	3684	__attribute__nonnull__(pTHX_1);
	3685	#define PERL_ARGS_ASSERT_SAVE_NOGV \
	3686	assert(gv)
	3687
	3688	/* PERL_CALLCONV void Perl_save_op(pTHX); */
	3689	PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off);
	3690	PERL_CALLCONV void Perl_save_pptr(pTHX_ char** pptr)
	3691	__attribute__nonnull__(pTHX_1);
	3692	#define PERL_ARGS_ASSERT_SAVE_PPTR \
	3693	assert(pptr)
	3694
	3695	PERL_CALLCONV void Perl_save_pushi32ptr(pTHX_ const I32 i, void *const ptr, const int type);
	3696	PERL_CALLCONV void Perl_save_pushptr(pTHX_ void *const ptr, const int type);
	3697	PERL_CALLCONV void Perl_save_pushptrptr(pTHX_ void const ptr1, void const ptr2, const int type);
	3698	PERL_CALLCONV void Perl_save_re_context(pTHX);
	3699	PERL_CALLCONV SV* Perl_save_scalar(pTHX_ GV* gv)
	3700	__attribute__nonnull__(pTHX_1);
	3701	#define PERL_ARGS_ASSERT_SAVE_SCALAR \
	3702	assert(gv)
	3703
	3704	PERL_CALLCONV void Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val)
	3705	__attribute__nonnull__(pTHX_1);
	3706	#define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \
	3707	assert(sv)
	3708
	3709	PERL_CALLCONV void Perl_save_shared_pvref(pTHX_ char** str)
	3710	__attribute__nonnull__(pTHX_1);
	3711	#define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \
	3712	assert(str)
	3713
	3714	PERL_CALLCONV void Perl_save_sptr(pTHX_ SV** sptr)
	3715	__attribute__nonnull__(pTHX_1);
	3716	#define PERL_ARGS_ASSERT_SAVE_SPTR \
	3717	assert(sptr)
	3718
	3719	PERL_CALLCONV void Perl_save_strlen(pTHX_ STRLEN* ptr)
	3720	__attribute__nonnull__(pTHX_1);
	3721	#define PERL_ARGS_ASSERT_SAVE_STRLEN \
	3722	assert(ptr)
	3723
	3724	PERL_CALLCONV SV* Perl_save_svref(pTHX_ SV** sptr)
	3725	__attribute__nonnull__(pTHX_1);
	3726	#define PERL_ARGS_ASSERT_SAVE_SVREF \
	3727	assert(sptr)
	3728
	3729	PERL_CALLCONV void Perl_save_vptr(pTHX_ void *ptr)
	3730	__attribute__nonnull__(pTHX_1);
	3731	#define PERL_ARGS_ASSERT_SAVE_VPTR \
	3732	assert(ptr)
	3733
	3734	PERL_CALLCONV char* Perl_savepv(pTHX_ const char* pv)
	3735	__attribute__malloc__
	3736	__attribute__warn_unused_result__;
	3737
	3738	PERL_CALLCONV char* Perl_savepvn(pTHX_ const char* pv, I32 len)
	3739	__attribute__malloc__
	3740	__attribute__warn_unused_result__;
	3741
	3742	PERL_CALLCONV char* Perl_savesharedpv(pTHX_ const char* pv)
	3743	__attribute__malloc__
	3744	__attribute__warn_unused_result__;
	3745
	3746	PERL_CALLCONV char* Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len)
	3747	__attribute__malloc__
	3748	__attribute__warn_unused_result__;
	3749
	3750	PERL_CALLCONV char* Perl_savesharedsvpv(pTHX_ SV *sv)
	3751	__attribute__malloc__
	3752	__attribute__warn_unused_result__
	3753	__attribute__nonnull__(pTHX_1);
	3754	#define PERL_ARGS_ASSERT_SAVESHAREDSVPV \
	3755	assert(sv)
	3756
	3757	PERL_CALLCONV void Perl_savestack_grow(pTHX);
	3758	PERL_CALLCONV void Perl_savestack_grow_cnt(pTHX_ I32 need);
	3759	PERL_CALLCONV char* Perl_savesvpv(pTHX_ SV* sv)
	3760	__attribute__malloc__
	3761	__attribute__warn_unused_result__
	3762	__attribute__nonnull__(pTHX_1);
	3763	#define PERL_ARGS_ASSERT_SAVESVPV \
	3764	assert(sv)
	3765
	3766	PERL_CALLCONV OP* Perl_sawparens(pTHX_ OP* o);
	3767	PERL_CALLCONV OP* Perl_scalar(pTHX_ OP* o);
	3768	PERL_CALLCONV OP* Perl_scalarvoid(pTHX_ OP* o)
	3769	__attribute__nonnull__(pTHX_1);
	3770	#define PERL_ARGS_ASSERT_SCALARVOID \
	3771	assert(o)
	3772
	3773	PERL_CALLCONV NV Perl_scan_bin(pTHX_ const char* start, STRLEN len, STRLEN* retlen)
	3774	__attribute__nonnull__(pTHX_1)
	3775	__attribute__nonnull__(pTHX_3);
	3776	#define PERL_ARGS_ASSERT_SCAN_BIN \
	3777	assert(start); assert(retlen)
	3778
	3779	PERL_CALLCONV NV Perl_scan_hex(pTHX_ const char* start, STRLEN len, STRLEN* retlen)
	3780	__attribute__nonnull__(pTHX_1)
	3781	__attribute__nonnull__(pTHX_3);
	3782	#define PERL_ARGS_ASSERT_SCAN_HEX \
	3783	assert(start); assert(retlen)
	3784
	3785	PERL_CALLCONV char* Perl_scan_num(pTHX_ const char* s, YYSTYPE *lvalp)
	3786	__attribute__nonnull__(pTHX_1)
	3787	__attribute__nonnull__(pTHX_2);
	3788	#define PERL_ARGS_ASSERT_SCAN_NUM \
	3789	assert(s); assert(lvalp)
	3790
	3791	PERL_CALLCONV NV Perl_scan_oct(pTHX_ const char* start, STRLEN len, STRLEN* retlen)
	3792	__attribute__nonnull__(pTHX_1)
	3793	__attribute__nonnull__(pTHX_3);
	3794	#define PERL_ARGS_ASSERT_SCAN_OCT \
	3795	assert(start); assert(retlen)
	3796
	3797	PERL_CALLCONV const char* Perl_scan_version(pTHX_ const char s, SV rv, bool qv)
	3798	__attribute__nonnull__(pTHX_1)
	3799	__attribute__nonnull__(pTHX_2);
	3800	#define PERL_ARGS_ASSERT_SCAN_VERSION \
	3801	assert(s); assert(rv)
	3802
	3803	PERL_CALLCONV char* Perl_scan_vstring(pTHX_ const char s, const char const e, SV *sv)
	3804	__attribute__nonnull__(pTHX_1)
	3805	__attribute__nonnull__(pTHX_2)
	3806	__attribute__nonnull__(pTHX_3);
	3807	#define PERL_ARGS_ASSERT_SCAN_VSTRING \
	3808	assert(s); assert(e); assert(sv)
	3809
	3810	PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV bigstr, SV littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
	3811	__attribute__nonnull__(pTHX_1)
	3812	__attribute__nonnull__(pTHX_2)
	3813	__attribute__nonnull__(pTHX_5);
	3814	#define PERL_ARGS_ASSERT_SCREAMINSTR \
	3815	assert(bigstr); assert(littlestr); assert(old_posp)
	3816
	3817	PERL_CALLCONV U32 Perl_seed(pTHX);
	3818	PERL_CALLCONV void Perl_set_caret_X(pTHX);
	3819	PERL_CALLCONV void Perl_set_context(void *t)
	3820	__attribute__nonnull__(1);
	3821	#define PERL_ARGS_ASSERT_SET_CONTEXT \
	3822	assert(t)
	3823
	3824	PERL_CALLCONV void Perl_set_numeric_local(pTHX);
	3825	PERL_CALLCONV void Perl_set_numeric_radix(pTHX);
	3826	PERL_CALLCONV void Perl_set_numeric_standard(pTHX);
	3827	PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv)
	3828	__attribute__nonnull__(pTHX_1);
	3829	#define PERL_ARGS_ASSERT_SETDEFOUT \
	3830	assert(gv)
	3831
	3832	PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, I32 len, U32 hash)
	3833	__attribute__nonnull__(pTHX_1);
	3834	#define PERL_ARGS_ASSERT_SHARE_HEK \
	3835	assert(str)
	3836
	3837	PERL_CALLCONV void Perl_sortsv(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp)
	3838	__attribute__nonnull__(pTHX_3);
	3839	#define PERL_ARGS_ASSERT_SORTSV \
	3840	assert(cmp)
	3841
	3842	PERL_CALLCONV void Perl_sortsv_flags(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)
	3843	__attribute__nonnull__(pTHX_3);
	3844	#define PERL_ARGS_ASSERT_SORTSV_FLAGS \
	3845	assert(cmp)
	3846
	3847	PERL_CALLCONV SV Perl_stack_grow(pTHX_ SV sp, SV** p, SSize_t n)
	3848	__attribute__nonnull__(pTHX_1)
	3849	__attribute__nonnull__(pTHX_2);
	3850	#define PERL_ARGS_ASSERT_STACK_GROW \
	3851	assert(sp); assert(p)
	3852
	3853	PERL_CALLCONV PerlIO* Perl_start_glob(pTHX_ SV tmpglob, IO io)
	3854	__attribute__nonnull__(pTHX_1)
	3855	__attribute__nonnull__(pTHX_2);
	3856	#define PERL_ARGS_ASSERT_START_GLOB \
	3857	assert(tmpglob); assert(io)
	3858
	3859	PERL_CALLCONV I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags);
	3860	PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv)
	3861	__attribute__warn_unused_result__
	3862	__attribute__nonnull__(pTHX_1);
	3863	#define PERL_ARGS_ASSERT_STR_TO_VERSION \
	3864	assert(sv)
	3865
	3866	PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV* cv)
	3867	__attribute__nonnull__(pTHX_1);
	3868	#define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \
	3869	assert(cv)
	3870
	3871	/* PERL_CALLCONV bool sv_2bool(pTHX_ SV *const sv)
	3872	__attribute__nonnull__(pTHX_1); */
	3873
	3874	PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags)
	3875	__attribute__nonnull__(pTHX_1);
	3876	#define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \
	3877	assert(sv)
	3878
	3879	PERL_CALLCONV CV* Perl_sv_2cv(pTHX_ SV* sv, HV const st, GV const gvp, const I32 lref)
	3880	__attribute__nonnull__(pTHX_2)
	3881	__attribute__nonnull__(pTHX_3);
	3882	#define PERL_ARGS_ASSERT_SV_2CV \
	3883	assert(st); assert(gvp)
	3884
	3885	PERL_CALLCONV IO* Perl_sv_2io(pTHX_ SV *const sv)
	3886	__attribute__nonnull__(pTHX_1);
	3887	#define PERL_ARGS_ASSERT_SV_2IO \
	3888	assert(sv)
	3889
	3890	/* PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv)
	3891	__attribute__nonnull__(pTHX_1); */
	3892	#define PERL_ARGS_ASSERT_SV_2IV \
	3893	assert(sv)
	3894
	3895	PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags)
	3896	__attribute__nonnull__(pTHX_1);
	3897	#define PERL_ARGS_ASSERT_SV_2IV_FLAGS \
	3898	assert(sv)
	3899
	3900	PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv);
	3901	PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv)
	3902	__attribute__nonnull__(pTHX_1);
	3903	#define PERL_ARGS_ASSERT_SV_2NUM \
	3904	assert(sv)
	3905
	3906	PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV *const sv, const I32 flags)
	3907	__attribute__nonnull__(pTHX_1);
	3908	#define PERL_ARGS_ASSERT_SV_2NV_FLAGS \
	3909	assert(sv)
	3910
	3911	/* PERL_CALLCONV char* Perl_sv_2pv(pTHX_ SV sv, STRLEN lp)
	3912	__attribute__nonnull__(pTHX_1); */
	3913	#define PERL_ARGS_ASSERT_SV_2PV \
	3914	assert(sv)
	3915
	3916	PERL_CALLCONV char* Perl_sv_2pv_flags(pTHX_ SV const sv, STRLEN const lp, const I32 flags)
	3917	__attribute__nonnull__(pTHX_1);
	3918	#define PERL_ARGS_ASSERT_SV_2PV_FLAGS \
	3919	assert(sv)
	3920
	3921	/* PERL_CALLCONV char* Perl_sv_2pv_nolen(pTHX_ SV* sv)
	3922	__attribute__warn_unused_result__
	3923	__attribute__nonnull__(pTHX_1); */
	3924	#define PERL_ARGS_ASSERT_SV_2PV_NOLEN \
	3925	assert(sv)
	3926
	3927	PERL_CALLCONV char* Perl_sv_2pvbyte(pTHX_ SV sv, STRLEN const lp)
	3928	__attribute__nonnull__(pTHX_1);
	3929	#define PERL_ARGS_ASSERT_SV_2PVBYTE \
	3930	assert(sv)
	3931
	3932	/* PERL_CALLCONV char* Perl_sv_2pvbyte_nolen(pTHX_ SV* sv)
	3933	__attribute__warn_unused_result__
	3934	__attribute__nonnull__(pTHX_1); */
	3935	#define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN \
	3936	assert(sv)
	3937
	3938	PERL_CALLCONV char* Perl_sv_2pvutf8(pTHX_ SV sv, STRLEN const lp)
	3939	__attribute__nonnull__(pTHX_1);
	3940	#define PERL_ARGS_ASSERT_SV_2PVUTF8 \
	3941	assert(sv)
	3942
	3943	/* PERL_CALLCONV char* Perl_sv_2pvutf8_nolen(pTHX_ SV* sv)
	3944	__attribute__warn_unused_result__
	3945	__attribute__nonnull__(pTHX_1); */
	3946	#define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \
	3947	assert(sv)
	3948
	3949	/* PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv)
	3950	__attribute__nonnull__(pTHX_1); */
	3951	#define PERL_ARGS_ASSERT_SV_2UV \
	3952	assert(sv)
	3953
	3954	PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags)
	3955	__attribute__nonnull__(pTHX_1);
	3956	#define PERL_ARGS_ASSERT_SV_2UV_FLAGS \
	3957	assert(sv)
	3958
	3959	PERL_CALLCONV int Perl_sv_backoff(pTHX_ SV *const sv)
	3960	__attribute__nonnull__(pTHX_1);
	3961	#define PERL_ARGS_ASSERT_SV_BACKOFF \
	3962	assert(sv)
	3963
	3964	PERL_CALLCONV SV* Perl_sv_bless(pTHX_ SV const sv, HV const stash)
	3965	__attribute__nonnull__(pTHX_1)
	3966	__attribute__nonnull__(pTHX_2);
	3967	#define PERL_ARGS_ASSERT_SV_BLESS \
	3968	assert(sv); assert(stash)
	3969
	3970	PERL_CALLCONV bool Perl_sv_cat_decode(pTHX_ SV* dsv, SV encoding, SV ssv, int offset, char tstr, int tlen)
	3971	__attribute__nonnull__(pTHX_1)
	3972	__attribute__nonnull__(pTHX_2)
	3973	__attribute__nonnull__(pTHX_3)
	3974	__attribute__nonnull__(pTHX_4)
	3975	__attribute__nonnull__(pTHX_5);
	3976	#define PERL_ARGS_ASSERT_SV_CAT_DECODE \
	3977	assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr)
	3978
	3979	PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV const sv, const char ptr)
	3980	__attribute__nonnull__(pTHX_1);
	3981	#define PERL_ARGS_ASSERT_SV_CATPV \
	3982	assert(sv)
	3983
	3984	PERL_CALLCONV void Perl_sv_catpv_flags(pTHX_ SV dstr, const char sstr, const I32 flags)
	3985	__attribute__nonnull__(pTHX_1)
	3986	__attribute__nonnull__(pTHX_2);
	3987	#define PERL_ARGS_ASSERT_SV_CATPV_FLAGS \
	3988	assert(dstr); assert(sstr)
	3989
	3990	PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV const sv, const char const ptr)
	3991	__attribute__nonnull__(pTHX_1);
	3992	#define PERL_ARGS_ASSERT_SV_CATPV_MG \
	3993	assert(sv)
	3994
	3995	PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV const sv, const char const pat, ...)
	3996	__attribute__format__(__printf__,pTHX_2,pTHX_3)
	3997	__attribute__nonnull__(pTHX_1)
	3998	__attribute__nonnull__(pTHX_2);
	3999	#define PERL_ARGS_ASSERT_SV_CATPVF \
	4000	assert(sv); assert(pat)
	4001
	4002	PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV const sv, const char const pat, ...)
	4003	__attribute__format__(__printf__,pTHX_2,pTHX_3)
	4004	__attribute__nonnull__(pTHX_1)
	4005	__attribute__nonnull__(pTHX_2);
	4006	#define PERL_ARGS_ASSERT_SV_CATPVF_MG \
	4007	assert(sv); assert(pat)
	4008
	4009	/* PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV dsv, const char sstr, STRLEN len)
	4010	__attribute__nonnull__(pTHX_1)
	4011	__attribute__nonnull__(pTHX_2); */
	4012	#define PERL_ARGS_ASSERT_SV_CATPVN \
	4013	assert(dsv); assert(sstr)
	4014
	4015	PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV const dstr, const char sstr, const STRLEN len, const I32 flags)
	4016	__attribute__nonnull__(pTHX_1)
	4017	__attribute__nonnull__(pTHX_2);
	4018	#define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \
	4019	assert(dstr); assert(sstr)
	4020
	4021	/* PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV sv, const char ptr, STRLEN len)
	4022	__attribute__nonnull__(pTHX_1)
	4023	__attribute__nonnull__(pTHX_2); */
	4024	#define PERL_ARGS_ASSERT_SV_CATPVN_MG \
	4025	assert(sv); assert(ptr)
	4026
	4027	/* PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV dstr, SV sstr)
	4028	__attribute__nonnull__(pTHX_1); */
	4029	#define PERL_ARGS_ASSERT_SV_CATSV \
	4030	assert(dstr)
	4031
	4032	PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV const dsv, SV const ssv, const I32 flags)
	4033	__attribute__nonnull__(pTHX_1);
	4034	#define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \
	4035	assert(dsv)
	4036
	4037	/* PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV dsv, SV ssv)
	4038	__attribute__nonnull__(pTHX_1); */
	4039	#define PERL_ARGS_ASSERT_SV_CATSV_MG \
	4040	assert(dsv)
	4041
	4042	PERL_CALLCONV void Perl_sv_chop(pTHX_ SV const sv, const char const ptr)
	4043	__attribute__nonnull__(pTHX_1);
	4044	#define PERL_ARGS_ASSERT_SV_CHOP \
	4045	assert(sv)
	4046
	4047	PERL_CALLCONV I32 Perl_sv_clean_all(pTHX);
	4048	PERL_CALLCONV void Perl_sv_clean_objs(pTHX);
	4049	PERL_CALLCONV void Perl_sv_clear(pTHX_ SV *const orig_sv)
	4050	__attribute__nonnull__(pTHX_1);
	4051	#define PERL_ARGS_ASSERT_SV_CLEAR \
	4052	assert(orig_sv)
	4053
	4054	PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV const sv1, SV const sv2);
	4055	PERL_CALLCONV I32 Perl_sv_cmp_flags(pTHX_ SV const sv1, SV const sv2, const U32 flags);
	4056	PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV const sv1, SV const sv2);
	4057	PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV const sv1, SV const sv2, const U32 flags);
	4058	/* PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV const dsv, SV const ssv)
	4059	__attribute__nonnull__(pTHX_1)
	4060	__attribute__nonnull__(pTHX_2); */
	4061	#define PERL_ARGS_ASSERT_SV_COPYPV \
	4062	assert(dsv); assert(ssv)
	4063
	4064	PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV const dsv, SV const ssv, const I32 flags)
	4065	__attribute__nonnull__(pTHX_1)
	4066	__attribute__nonnull__(pTHX_2);
	4067	#define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \
	4068	assert(dsv); assert(ssv)
	4069
	4070	/* PERL_CALLCONV void Perl_sv_copypv_nomg(pTHX_ SV const dsv, SV const ssv)
	4071	__attribute__nonnull__(pTHX_1)
	4072	__attribute__nonnull__(pTHX_2); */
	4073
	4074	PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv);
	4075	PERL_CALLCONV void Perl_sv_dec_nomg(pTHX_ SV *const sv);
	4076	PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV const tsv, SV const sv)
	4077	__attribute__nonnull__(pTHX_1)
	4078	__attribute__nonnull__(pTHX_2);
	4079	#define PERL_ARGS_ASSERT_SV_DEL_BACKREF \
	4080	assert(tsv); assert(sv)
	4081
	4082	PERL_CALLCONV bool Perl_sv_derived_from(pTHX_ SV* sv, const char *const name)
	4083	__attribute__warn_unused_result__
	4084	__attribute__nonnull__(pTHX_1)
	4085	__attribute__nonnull__(pTHX_2);
	4086	#define PERL_ARGS_ASSERT_SV_DERIVED_FROM \
	4087	assert(sv); assert(name)
	4088
	4089	PERL_CALLCONV bool Perl_sv_derived_from_pv(pTHX_ SV* sv, const char *const name, U32 flags)
	4090	__attribute__warn_unused_result__
	4091	__attribute__nonnull__(pTHX_1)
	4092	__attribute__nonnull__(pTHX_2);
	4093	#define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PV \
	4094	assert(sv); assert(name)
	4095
	4096	PERL_CALLCONV bool Perl_sv_derived_from_pvn(pTHX_ SV* sv, const char *const name, const STRLEN len, U32 flags)
	4097	__attribute__warn_unused_result__
	4098	__attribute__nonnull__(pTHX_1)
	4099	__attribute__nonnull__(pTHX_2);
	4100	#define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PVN \
	4101	assert(sv); assert(name)
	4102
	4103	PERL_CALLCONV bool Perl_sv_derived_from_sv(pTHX_ SV* sv, SV *namesv, U32 flags)
	4104	__attribute__warn_unused_result__
	4105	__attribute__nonnull__(pTHX_1)
	4106	__attribute__nonnull__(pTHX_2);
	4107	#define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SV \
	4108	assert(sv); assert(namesv)
	4109
	4110	PERL_CALLCONV bool Perl_sv_destroyable(pTHX_ SV *sv);
	4111	PERL_CALLCONV bool Perl_sv_does(pTHX_ SV* sv, const char *const name)
	4112	__attribute__warn_unused_result__
	4113	__attribute__nonnull__(pTHX_1)
	4114	__attribute__nonnull__(pTHX_2);
	4115	#define PERL_ARGS_ASSERT_SV_DOES \
	4116	assert(sv); assert(name)
	4117
	4118	PERL_CALLCONV bool Perl_sv_does_pv(pTHX_ SV* sv, const char *const name, U32 flags)
	4119	__attribute__warn_unused_result__
	4120	__attribute__nonnull__(pTHX_1)
	4121	__attribute__nonnull__(pTHX_2);
	4122	#define PERL_ARGS_ASSERT_SV_DOES_PV \
	4123	assert(sv); assert(name)
	4124
	4125	PERL_CALLCONV bool Perl_sv_does_pvn(pTHX_ SV* sv, const char *const name, const STRLEN len, U32 flags)
	4126	__attribute__warn_unused_result__
	4127	__attribute__nonnull__(pTHX_1)
	4128	__attribute__nonnull__(pTHX_2);
	4129	#define PERL_ARGS_ASSERT_SV_DOES_PVN \
	4130	assert(sv); assert(name)
	4131
	4132	PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV* sv, SV* namesv, U32 flags)
	4133	__attribute__warn_unused_result__
	4134	__attribute__nonnull__(pTHX_1)
	4135	__attribute__nonnull__(pTHX_2);
	4136	#define PERL_ARGS_ASSERT_SV_DOES_SV \
	4137	assert(sv); assert(namesv)
	4138
	4139	PERL_CALLCONV void Perl_sv_dump(pTHX_ SV* sv)
	4140	__attribute__nonnull__(pTHX_1);
	4141	#define PERL_ARGS_ASSERT_SV_DUMP \
	4142	assert(sv)
	4143
	4144	/* PERL_CALLCONV I32 sv_eq(pTHX_ SV* sv1, SV* sv2); */
	4145	PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags);
	4146	/* PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv)
	4147	__attribute__nonnull__(pTHX_1); */
	4148	#define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \
	4149	assert(sv)
	4150
	4151	PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flags)
	4152	__attribute__nonnull__(pTHX_1);
	4153	#define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \
	4154	assert(sv)
	4155
	4156	PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv);
	4157	PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt)
	4158	__attribute__nonnull__(pTHX_1);
	4159	#define PERL_ARGS_ASSERT_SV_FREE2 \
	4160	assert(sv)
	4161
	4162	PERL_CALLCONV void Perl_sv_free_arenas(pTHX);
	4163	PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV const sv, PerlIO const fp, I32 append)
	4164	__attribute__nonnull__(pTHX_1)
	4165	__attribute__nonnull__(pTHX_2);
	4166	#define PERL_ARGS_ASSERT_SV_GETS \
	4167	assert(sv); assert(fp)
	4168
	4169	PERL_CALLCONV char* Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen)
	4170	__attribute__nonnull__(pTHX_1);
	4171	#define PERL_ARGS_ASSERT_SV_GROW \
	4172	assert(sv)
	4173
	4174	PERL_CALLCONV void Perl_sv_inc(pTHX_ SV *const sv);
	4175	PERL_CALLCONV void Perl_sv_inc_nomg(pTHX_ SV *const sv);
	4176	/* PERL_CALLCONV void Perl_sv_insert(pTHX_ SV const bigstr, const STRLEN offset, const STRLEN len, const char const little, const STRLEN littlelen)
	4177	__attribute__nonnull__(pTHX_1)
	4178	__attribute__nonnull__(pTHX_4); */
	4179	#define PERL_ARGS_ASSERT_SV_INSERT \
	4180	assert(bigstr); assert(little)
	4181
	4182	PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV const bigstr, const STRLEN offset, const STRLEN len, const char const little, const STRLEN littlelen, const U32 flags)
	4183	__attribute__nonnull__(pTHX_1)
	4184	__attribute__nonnull__(pTHX_4);
	4185	#define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \
	4186	assert(bigstr); assert(little)
	4187
	4188	PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name)
	4189	__attribute__nonnull__(pTHX_2);
	4190	#define PERL_ARGS_ASSERT_SV_ISA \
	4191	assert(name)
	4192
	4193	PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV* sv);
	4194	PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv)
	4195	__attribute__nonnull__(pTHX_1);
	4196	#define PERL_ARGS_ASSERT_SV_IV \
	4197	assert(sv)
	4198
	4199	PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv);
	4200	PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv);
	4201	PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV *const sv)
	4202	__attribute__nonnull__(pTHX_1);
	4203	#define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \
	4204	assert(sv)
	4205
	4206	PERL_CALLCONV void Perl_sv_magic(pTHX_ SV const sv, SV const obj, const int how, const char *const name, const I32 namlen)
	4207	__attribute__nonnull__(pTHX_1);
	4208	#define PERL_ARGS_ASSERT_SV_MAGIC \
	4209	assert(sv)
	4210
	4211	PERL_CALLCONV MAGIC * Perl_sv_magicext(pTHX_ SV const sv, SV const obj, const int how, const MGVTBL const vtbl, const char const name, const I32 namlen)
	4212	__attribute__nonnull__(pTHX_1);
	4213	#define PERL_ARGS_ASSERT_SV_MAGICEXT \
	4214	assert(sv)
	4215
	4216	PERL_CALLCONV MAGIC * Perl_sv_magicext_mglob(pTHX_ SV *sv)
	4217	__attribute__nonnull__(pTHX_1);
	4218	#define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB \
	4219	assert(sv)
	4220
	4221	/* PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
	4222	__attribute__malloc__
	4223	__attribute__warn_unused_result__; */
	4224
	4225	PERL_CALLCONV SV* Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags)
	4226	__attribute__malloc__
	4227	__attribute__warn_unused_result__;
	4228
	4229	PERL_CALLCONV SV* Perl_sv_newmortal(pTHX)
	4230	__attribute__warn_unused_result__;
	4231
	4232	PERL_CALLCONV SV* Perl_sv_newref(pTHX_ SV *const sv);
	4233	/* PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV sv); /
	4234	PERL_CALLCONV void Perl_sv_nosharing(pTHX_ SV *sv);
	4235	PERL_CALLCONV NV Perl_sv_nv(pTHX_ SV* sv)
	4236	__attribute__nonnull__(pTHX_1);
	4237	#define PERL_ARGS_ASSERT_SV_NV \
	4238	assert(sv)
	4239
	4240	PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv);
	4241	PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV const sv, I32 const offsetp)
	4242	__attribute__nonnull__(pTHX_2);
	4243	#define PERL_ARGS_ASSERT_SV_POS_B2U \
	4244	assert(offsetp)
	4245
	4246	PERL_CALLCONV STRLEN Perl_sv_pos_b2u_flags(pTHX_ SV *const sv, STRLEN const offset, U32 flags)
	4247	__attribute__nonnull__(pTHX_1);
	4248	#define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \
	4249	assert(sv)
	4250
	4251	PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV const sv, I32 const offsetp, I32 *const lenp)
	4252	__attribute__nonnull__(pTHX_2);
	4253	#define PERL_ARGS_ASSERT_SV_POS_U2B \
	4254	assert(offsetp)
	4255
	4256	PERL_CALLCONV STRLEN Perl_sv_pos_u2b_flags(pTHX_ SV const sv, STRLEN uoffset, STRLEN const lenp, U32 flags)
	4257	__attribute__nonnull__(pTHX_1);
	4258	#define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \
	4259	assert(sv)
	4260
	4261	/* PERL_CALLCONV char* Perl_sv_pv(pTHX_ SV *sv)
	4262	__attribute__warn_unused_result__
	4263	__attribute__nonnull__(pTHX_1); */
	4264	#define PERL_ARGS_ASSERT_SV_PV \
	4265	assert(sv)
	4266
	4267	/* PERL_CALLCONV char* Perl_sv_pvbyte(pTHX_ SV *sv)
	4268	__attribute__warn_unused_result__
	4269	__attribute__nonnull__(pTHX_1); */
	4270	#define PERL_ARGS_ASSERT_SV_PVBYTE \
	4271	assert(sv)
	4272
	4273	PERL_CALLCONV char* Perl_sv_pvbyten(pTHX_ SV sv, STRLEN lp)
	4274	__attribute__nonnull__(pTHX_1)
	4275	__attribute__nonnull__(pTHX_2);
	4276	#define PERL_ARGS_ASSERT_SV_PVBYTEN \
	4277	assert(sv); assert(lp)
	4278
	4279	PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV const sv, STRLEN const lp)
	4280	__attribute__nonnull__(pTHX_1);
	4281	#define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \
	4282	assert(sv)
	4283
	4284	PERL_CALLCONV char* Perl_sv_pvn(pTHX_ SV sv, STRLEN lp)
	4285	__attribute__nonnull__(pTHX_1)
	4286	__attribute__nonnull__(pTHX_2);
	4287	#define PERL_ARGS_ASSERT_SV_PVN \
	4288	assert(sv); assert(lp)
	4289
	4290	/* PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp)
	4291	__attribute__nonnull__(pTHX_1); */
	4292	#define PERL_ARGS_ASSERT_SV_PVN_FORCE \
	4293	assert(sv)
	4294
	4295	PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV const sv, STRLEN const lp, const I32 flags)
	4296	__attribute__nonnull__(pTHX_1);
	4297	#define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \
	4298	assert(sv)
	4299
	4300	PERL_CALLCONV char* Perl_sv_pvn_nomg(pTHX_ SV* sv, STRLEN* lp)
	4301	__attribute__nonnull__(pTHX_1);
	4302	#define PERL_ARGS_ASSERT_SV_PVN_NOMG \
	4303	assert(sv)
	4304
	4305	/* PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv)
	4306	__attribute__warn_unused_result__
	4307	__attribute__nonnull__(pTHX_1); */
	4308	#define PERL_ARGS_ASSERT_SV_PVUTF8 \
	4309	assert(sv)
	4310
	4311	PERL_CALLCONV char* Perl_sv_pvutf8n(pTHX_ SV sv, STRLEN lp)
	4312	__attribute__nonnull__(pTHX_1)
	4313	__attribute__nonnull__(pTHX_2);
	4314	#define PERL_ARGS_ASSERT_SV_PVUTF8N \
	4315	assert(sv); assert(lp)
	4316
	4317	PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV const sv, STRLEN const lp)
	4318	__attribute__nonnull__(pTHX_1);
	4319	#define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \
	4320	assert(sv)
	4321
	4322	PERL_CALLCONV char* Perl_sv_recode_to_utf8(pTHX_ SV* sv, SV *encoding)
	4323	__attribute__nonnull__(pTHX_1)
	4324	__attribute__nonnull__(pTHX_2);
	4325	#define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \
	4326	assert(sv); assert(encoding)
	4327
	4328	PERL_CALLCONV SV* Perl_sv_ref(pTHX_ SV dst, const SV const sv, const int ob)
	4329	__attribute__nonnull__(pTHX_2);
	4330	#define PERL_ARGS_ASSERT_SV_REF \
	4331	assert(sv)
	4332
	4333	PERL_CALLCONV const char* Perl_sv_reftype(pTHX_ const SV *const sv, const int ob)
	4334	__attribute__warn_unused_result__
	4335	__attribute__nonnull__(pTHX_1);
	4336	#define PERL_ARGS_ASSERT_SV_REFTYPE \
	4337	assert(sv)
	4338
	4339	PERL_CALLCONV void Perl_sv_replace(pTHX_ SV const sv, SV const nsv)
	4340	__attribute__nonnull__(pTHX_1)
	4341	__attribute__nonnull__(pTHX_2);
	4342	#define PERL_ARGS_ASSERT_SV_REPLACE \
	4343	assert(sv); assert(nsv)
	4344
	4345	PERL_CALLCONV void Perl_sv_report_used(pTHX);
	4346	PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash)
	4347	__attribute__nonnull__(pTHX_1);
	4348	#define PERL_ARGS_ASSERT_SV_RESET \
	4349	assert(s)
	4350
	4351	PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash);
	4352	PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv)
	4353	__attribute__nonnull__(pTHX_1);
	4354	#define PERL_ARGS_ASSERT_SV_RVWEAKEN \
	4355	assert(sv)
	4356
	4357	PERL_CALLCONV void Perl_sv_sethek(pTHX_ SV const sv, const HEK const hek)
	4358	__attribute__nonnull__(pTHX_1);
	4359	#define PERL_ARGS_ASSERT_SV_SETHEK \
	4360	assert(sv)
	4361
	4362	PERL_CALLCONV void Perl_sv_setiv(pTHX_ SV *const sv, const IV num)
	4363	__attribute__nonnull__(pTHX_1);
	4364	#define PERL_ARGS_ASSERT_SV_SETIV \
	4365	assert(sv)
	4366
	4367	PERL_CALLCONV void Perl_sv_setiv_mg(pTHX_ SV *const sv, const IV i)
	4368	__attribute__nonnull__(pTHX_1);
	4369	#define PERL_ARGS_ASSERT_SV_SETIV_MG \
	4370	assert(sv)
	4371
	4372	PERL_CALLCONV void Perl_sv_setnv(pTHX_ SV *const sv, const NV num)
	4373	__attribute__nonnull__(pTHX_1);
	4374	#define PERL_ARGS_ASSERT_SV_SETNV \
	4375	assert(sv)
	4376
	4377	PERL_CALLCONV void Perl_sv_setnv_mg(pTHX_ SV *const sv, const NV num)
	4378	__attribute__nonnull__(pTHX_1);
	4379	#define PERL_ARGS_ASSERT_SV_SETNV_MG \
	4380	assert(sv)
	4381
	4382	PERL_CALLCONV void Perl_sv_setpv(pTHX_ SV const sv, const char const ptr)
	4383	__attribute__nonnull__(pTHX_1);
	4384	#define PERL_ARGS_ASSERT_SV_SETPV \
	4385	assert(sv)
	4386
	4387	PERL_CALLCONV void Perl_sv_setpv_mg(pTHX_ SV const sv, const char const ptr)
	4388	__attribute__nonnull__(pTHX_1);
	4389	#define PERL_ARGS_ASSERT_SV_SETPV_MG \
	4390	assert(sv)
	4391
	4392	PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV const sv, const char const pat, ...)
	4393	__attribute__format__(__printf__,pTHX_2,pTHX_3)
	4394	__attribute__nonnull__(pTHX_1)
	4395	__attribute__nonnull__(pTHX_2);
	4396	#define PERL_ARGS_ASSERT_SV_SETPVF \
	4397	assert(sv); assert(pat)
	4398
	4399	PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV const sv, const char const pat, ...)
	4400	__attribute__format__(__printf__,pTHX_2,pTHX_3)
	4401	__attribute__nonnull__(pTHX_1)
	4402	__attribute__nonnull__(pTHX_2);
	4403	#define PERL_ARGS_ASSERT_SV_SETPVF_MG \
	4404	assert(sv); assert(pat)
	4405
	4406	PERL_CALLCONV void Perl_sv_setpviv(pTHX_ SV *const sv, const IV num)
	4407	__attribute__nonnull__(pTHX_1);
	4408	#define PERL_ARGS_ASSERT_SV_SETPVIV \
	4409	assert(sv)
	4410
	4411	PERL_CALLCONV void Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv)
	4412	__attribute__nonnull__(pTHX_1);
	4413	#define PERL_ARGS_ASSERT_SV_SETPVIV_MG \
	4414	assert(sv)
	4415
	4416	PERL_CALLCONV void Perl_sv_setpvn(pTHX_ SV const sv, const char const ptr, const STRLEN len)
	4417	__attribute__nonnull__(pTHX_1);
	4418	#define PERL_ARGS_ASSERT_SV_SETPVN \
	4419	assert(sv)
	4420
	4421	PERL_CALLCONV void Perl_sv_setpvn_mg(pTHX_ SV const sv, const char const ptr, const STRLEN len)
	4422	__attribute__nonnull__(pTHX_1)
	4423	__attribute__nonnull__(pTHX_2);
	4424	#define PERL_ARGS_ASSERT_SV_SETPVN_MG \
	4425	assert(sv); assert(ptr)
	4426
	4427	PERL_CALLCONV SV* Perl_sv_setref_iv(pTHX_ SV const rv, const char const classname, const IV iv)
	4428	__attribute__nonnull__(pTHX_1);
	4429	#define PERL_ARGS_ASSERT_SV_SETREF_IV \
	4430	assert(rv)
	4431
	4432	PERL_CALLCONV SV* Perl_sv_setref_nv(pTHX_ SV const rv, const char const classname, const NV nv)
	4433	__attribute__nonnull__(pTHX_1);
	4434	#define PERL_ARGS_ASSERT_SV_SETREF_NV \
	4435	assert(rv)
	4436
	4437	PERL_CALLCONV SV* Perl_sv_setref_pv(pTHX_ SV const rv, const char const classname, void *const pv)
	4438	__attribute__nonnull__(pTHX_1);
	4439	#define PERL_ARGS_ASSERT_SV_SETREF_PV \
	4440	assert(rv)
	4441
	4442	PERL_CALLCONV SV* Perl_sv_setref_pvn(pTHX_ SV const rv, const char const classname, const char *const pv, const STRLEN n)
	4443	__attribute__nonnull__(pTHX_1)
	4444	__attribute__nonnull__(pTHX_3);
	4445	#define PERL_ARGS_ASSERT_SV_SETREF_PVN \
	4446	assert(rv); assert(pv)
	4447
	4448	PERL_CALLCONV SV* Perl_sv_setref_uv(pTHX_ SV const rv, const char const classname, const UV uv)
	4449	__attribute__nonnull__(pTHX_1);
	4450	#define PERL_ARGS_ASSERT_SV_SETREF_UV \
	4451	assert(rv)
	4452
	4453	/* PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV dstr, SV sstr)
	4454	__attribute__nonnull__(pTHX_1); */
	4455	#define PERL_ARGS_ASSERT_SV_SETSV \
	4456	assert(dstr)
	4457
	4458	PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV dstr, SV sstr, const I32 flags)
	4459	__attribute__nonnull__(pTHX_1);
	4460	#define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \
	4461	assert(dstr)
	4462
	4463	PERL_CALLCONV void Perl_sv_setsv_mg(pTHX_ SV const dstr, SV const sstr)
	4464	__attribute__nonnull__(pTHX_1);
	4465	#define PERL_ARGS_ASSERT_SV_SETSV_MG \
	4466	assert(dstr)
	4467
	4468	PERL_CALLCONV void Perl_sv_setuv(pTHX_ SV *const sv, const UV num)
	4469	__attribute__nonnull__(pTHX_1);
	4470	#define PERL_ARGS_ASSERT_SV_SETUV \
	4471	assert(sv)
	4472
	4473	PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u)
	4474	__attribute__nonnull__(pTHX_1);
	4475	#define PERL_ARGS_ASSERT_SV_SETUV_MG \
	4476	assert(sv)
	4477
	4478	/* PERL_CALLCONV void Perl_sv_taint(pTHX_ SV* sv)
	4479	__attribute__nonnull__(pTHX_1); */
	4480	#define PERL_ARGS_ASSERT_SV_TAINT \
	4481	assert(sv)
	4482
	4483	PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV *const sv)
	4484	__attribute__warn_unused_result__
	4485	__attribute__nonnull__(pTHX_1);
	4486	#define PERL_ARGS_ASSERT_SV_TAINTED \
	4487	assert(sv)
	4488
	4489	PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *const sv);
	4490	PERL_CALLCONV char* Perl_sv_uni_display(pTHX_ SV dsv, SV ssv, STRLEN pvlim, UV flags)
	4491	__attribute__warn_unused_result__
	4492	__attribute__nonnull__(pTHX_1)
	4493	__attribute__nonnull__(pTHX_2);
	4494	#define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \
	4495	assert(dsv); assert(ssv)
	4496
	4497	PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV *const sv, const int type)
	4498	__attribute__nonnull__(pTHX_1);
	4499	#define PERL_ARGS_ASSERT_SV_UNMAGIC \
	4500	assert(sv)
	4501
	4502	PERL_CALLCONV int Perl_sv_unmagicext(pTHX_ SV const sv, const int type, MGVTBL vtbl)
	4503	__attribute__nonnull__(pTHX_1);
	4504	#define PERL_ARGS_ASSERT_SV_UNMAGICEXT \
	4505	assert(sv)
	4506
	4507	/* PERL_CALLCONV void Perl_sv_unref(pTHX_ SV* sv)
	4508	__attribute__nonnull__(pTHX_1); */
	4509	#define PERL_ARGS_ASSERT_SV_UNREF \
	4510	assert(sv)
	4511
	4512	PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags)
	4513	__attribute__nonnull__(pTHX_1);
	4514	#define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \
	4515	assert(ref)
	4516
	4517	PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV *const sv)
	4518	__attribute__nonnull__(pTHX_1);
	4519	#define PERL_ARGS_ASSERT_SV_UNTAINT \
	4520	assert(sv)
	4521
	4522	PERL_CALLCONV void Perl_sv_upgrade(pTHX_ SV *const sv, svtype new_type)
	4523	__attribute__nonnull__(pTHX_1);
	4524	#define PERL_ARGS_ASSERT_SV_UPGRADE \
	4525	assert(sv)
	4526
	4527	/* PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV* sv, char* ptr, STRLEN len)
	4528	__attribute__nonnull__(pTHX_1); */
	4529	#define PERL_ARGS_ASSERT_SV_USEPVN \
	4530	assert(sv)
	4531
	4532	PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV const sv, char ptr, const STRLEN len, const U32 flags)
	4533	__attribute__nonnull__(pTHX_1);
	4534	#define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \
	4535	assert(sv)
	4536
	4537	/* PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV sv, char ptr, STRLEN len)
	4538	__attribute__nonnull__(pTHX_1); */
	4539	#define PERL_ARGS_ASSERT_SV_USEPVN_MG \
	4540	assert(sv)
	4541
	4542	PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV *const sv)
	4543	__attribute__nonnull__(pTHX_1);
	4544	#define PERL_ARGS_ASSERT_SV_UTF8_DECODE \
	4545	assert(sv)
	4546
	4547	PERL_CALLCONV bool Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok)
	4548	__attribute__nonnull__(pTHX_1);
	4549	#define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \
	4550	assert(sv)
	4551
	4552	PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV *const sv)
	4553	__attribute__nonnull__(pTHX_1);
	4554	#define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \
	4555	assert(sv)
	4556
	4557	/* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv)
	4558	__attribute__nonnull__(pTHX_1); */
	4559	#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \
	4560	assert(sv)
	4561
	4562	/* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags)
	4563	__attribute__nonnull__(pTHX_1); */
	4564
	4565	PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra)
	4566	__attribute__nonnull__(pTHX_1);
	4567	#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \
	4568	assert(sv)
	4569
	4570	/* PERL_CALLCONV STRLEN sv_utf8_upgrade_nomg(pTHX_ SV *sv)
	4571	__attribute__nonnull__(pTHX_1); */
	4572
	4573	PERL_CALLCONV UV Perl_sv_uv(pTHX_ SV* sv)
	4574	__attribute__nonnull__(pTHX_1);
	4575	#define PERL_ARGS_ASSERT_SV_UV \
	4576	assert(sv)
	4577
	4578	PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV const sv, const char const pat, va_list *const args)
	4579	__attribute__nonnull__(pTHX_1)
	4580	__attribute__nonnull__(pTHX_2);
	4581	#define PERL_ARGS_ASSERT_SV_VCATPVF \
	4582	assert(sv); assert(pat)
	4583
	4584	PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV const sv, const char const pat, va_list *const args)
	4585	__attribute__nonnull__(pTHX_1)
	4586	__attribute__nonnull__(pTHX_2);
	4587	#define PERL_ARGS_ASSERT_SV_VCATPVF_MG \
	4588	assert(sv); assert(pat)
	4589
	4590	PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV const sv, const char const pat, const STRLEN patlen, va_list const args, SV const svargs, const I32 svmax, bool const maybe_tainted)
	4591	__attribute__nonnull__(pTHX_1)
	4592	__attribute__nonnull__(pTHX_2);
	4593	#define PERL_ARGS_ASSERT_SV_VCATPVFN \
	4594	assert(sv); assert(pat)
	4595
	4596	PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV const sv, const char const pat, const STRLEN patlen, va_list const args, SV const svargs, const I32 svmax, bool const maybe_tainted, const U32 flags)
	4597	__attribute__nonnull__(pTHX_1)
	4598	__attribute__nonnull__(pTHX_2);
	4599	#define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \
	4600	assert(sv); assert(pat)
	4601
	4602	PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV const sv, const char const pat, va_list *const args)
	4603	__attribute__nonnull__(pTHX_1)
	4604	__attribute__nonnull__(pTHX_2);
	4605	#define PERL_ARGS_ASSERT_SV_VSETPVF \
	4606	assert(sv); assert(pat)
	4607
	4608	PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV const sv, const char const pat, va_list *const args)
	4609	__attribute__nonnull__(pTHX_1)
	4610	__attribute__nonnull__(pTHX_2);
	4611	#define PERL_ARGS_ASSERT_SV_VSETPVF_MG \
	4612	assert(sv); assert(pat)
	4613
	4614	PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV const sv, const char const pat, const STRLEN patlen, va_list const args, SV const svargs, const I32 svmax, bool const maybe_tainted)
	4615	__attribute__nonnull__(pTHX_1)
	4616	__attribute__nonnull__(pTHX_2);
	4617	#define PERL_ARGS_ASSERT_SV_VSETPVFN \
	4618	assert(sv); assert(pat)
	4619
	4620	PERL_CALLCONV UV Perl_swash_fetch(pTHX_ SV swash, const U8 ptr, bool do_utf8)
	4621	__attribute__nonnull__(pTHX_1)
	4622	__attribute__nonnull__(pTHX_2);
	4623	#define PERL_ARGS_ASSERT_SWASH_FETCH \
	4624	assert(swash); assert(ptr)
	4625
	4626	PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none)
	4627	__attribute__warn_unused_result__
	4628	__attribute__nonnull__(pTHX_1)
	4629	__attribute__nonnull__(pTHX_2)
	4630	__attribute__nonnull__(pTHX_3);
	4631	#define PERL_ARGS_ASSERT_SWASH_INIT \
	4632	assert(pkg); assert(name); assert(listsv)
	4633
	4634	PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv)
	4635	__attribute__nonnull__(1)
	4636	__attribute__nonnull__(2);
	4637	#define PERL_ARGS_ASSERT_SYS_INIT \
	4638	assert(argc); assert(argv)
	4639
	4640	PERL_CALLCONV void Perl_sys_init3(int* argc, char* argv, char* env)
	4641	__attribute__nonnull__(1)
	4642	__attribute__nonnull__(2)
	4643	__attribute__nonnull__(3);
	4644	#define PERL_ARGS_ASSERT_SYS_INIT3 \
	4645	assert(argc); assert(argv); assert(env)
	4646
	4647	PERL_CALLCONV void Perl_sys_term(void);
	4648	PERL_CALLCONV void Perl_taint_env(pTHX);
	4649	PERL_CALLCONV void Perl_taint_proper(pTHX_ const char* f, const char *const s)
	4650	__attribute__nonnull__(pTHX_2);
	4651	#define PERL_ARGS_ASSERT_TAINT_PROPER \
	4652	assert(s)
	4653
	4654	PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV methname, SV sp, SV const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...)
	4655	__attribute__nonnull__(pTHX_1)
	4656	__attribute__nonnull__(pTHX_2)
	4657	__attribute__nonnull__(pTHX_3)
	4658	__attribute__nonnull__(pTHX_4);
	4659	#define PERL_ARGS_ASSERT_TIED_METHOD \
	4660	assert(methname); assert(sp); assert(sv); assert(mg)
	4661
	4662	PERL_CALLCONV void Perl_tmps_grow(pTHX_ SSize_t n);
	4663	/* PERL_CALLCONV UV Perl_to_uni_fold(pTHX_ UV c, U8 p, STRLEN lenp)
	4664	__attribute__nonnull__(pTHX_2)
	4665	__attribute__nonnull__(pTHX_3); */
	4666
	4667	PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 p, STRLEN lenp)
	4668	__attribute__nonnull__(pTHX_2)
	4669	__attribute__nonnull__(pTHX_3);
	4670	#define PERL_ARGS_ASSERT_TO_UNI_LOWER \
	4671	assert(p); assert(lenp)
	4672
	4673	PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c)
	4674	__attribute__deprecated__
	4675	__attribute__warn_unused_result__
	4676	__attribute__pure__;
	4677
	4678	PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 p, STRLEN lenp)
	4679	__attribute__nonnull__(pTHX_2)
	4680	__attribute__nonnull__(pTHX_3);
	4681	#define PERL_ARGS_ASSERT_TO_UNI_TITLE \
	4682	assert(p); assert(lenp)
	4683
	4684	PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c)
	4685	__attribute__deprecated__
	4686	__attribute__warn_unused_result__
	4687	__attribute__pure__;
	4688
	4689	PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 p, STRLEN lenp)
	4690	__attribute__nonnull__(pTHX_2)
	4691	__attribute__nonnull__(pTHX_3);
	4692	#define PERL_ARGS_ASSERT_TO_UNI_UPPER \
	4693	assert(p); assert(lenp)
	4694
	4695	PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c)
	4696	__attribute__deprecated__
	4697	__attribute__warn_unused_result__
	4698	__attribute__pure__;
	4699
	4700	PERL_CALLCONV UV Perl_to_utf8_case(pTHX_ const U8 p, U8 ustrp, STRLEN lenp, SV swashp, const char normal, const char *special)
	4701	__attribute__nonnull__(pTHX_1)
	4702	__attribute__nonnull__(pTHX_2)
	4703	__attribute__nonnull__(pTHX_4)
	4704	__attribute__nonnull__(pTHX_5);
	4705	#define PERL_ARGS_ASSERT_TO_UTF8_CASE \
	4706	assert(p); assert(ustrp); assert(swashp); assert(normal)
	4707
	4708	/* PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 p, U8 ustrp, STRLEN *lenp)
	4709	__attribute__nonnull__(pTHX_1)
	4710	__attribute__nonnull__(pTHX_2); */
	4711	#define PERL_ARGS_ASSERT_TO_UTF8_FOLD \
	4712	assert(p); assert(ustrp)
	4713
	4714	/* PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 p, U8 ustrp, STRLEN *lenp)
	4715	__attribute__nonnull__(pTHX_1)
	4716	__attribute__nonnull__(pTHX_2); */
	4717	#define PERL_ARGS_ASSERT_TO_UTF8_LOWER \
	4718	assert(p); assert(ustrp)
	4719
	4720	/* PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 p, U8 ustrp, STRLEN *lenp)
	4721	__attribute__nonnull__(pTHX_1)
	4722	__attribute__nonnull__(pTHX_2); */
	4723	#define PERL_ARGS_ASSERT_TO_UTF8_TITLE \
	4724	assert(p); assert(ustrp)
	4725
	4726	/* PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 p, U8 ustrp, STRLEN *lenp)
	4727	__attribute__nonnull__(pTHX_1)
	4728	__attribute__nonnull__(pTHX_2); */
	4729	#define PERL_ARGS_ASSERT_TO_UTF8_UPPER \
	4730	assert(p); assert(ustrp)
	4731
	4732	PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags);
	4733	PERL_CALLCONV bool Perl_try_amagic_un(pTHX_ int method, int flags);
	4734	PERL_CALLCONV I32 Perl_unpack_str(pTHX_ const char pat, const char patend, const char s, const char strbeg, const char strend, char *new_s, I32 ocnt, U32 flags)
	4735	__attribute__nonnull__(pTHX_1)
	4736	__attribute__nonnull__(pTHX_2)
	4737	__attribute__nonnull__(pTHX_3)
	4738	__attribute__nonnull__(pTHX_5);
	4739	#define PERL_ARGS_ASSERT_UNPACK_STR \
	4740	assert(pat); assert(patend); assert(s); assert(strend)
	4741
	4742	PERL_CALLCONV I32 Perl_unpackstring(pTHX_ const char pat, const char patend, const char s, const char strend, U32 flags)
	4743	__attribute__nonnull__(pTHX_1)
	4744	__attribute__nonnull__(pTHX_2)
	4745	__attribute__nonnull__(pTHX_3)
	4746	__attribute__nonnull__(pTHX_4);
	4747	#define PERL_ARGS_ASSERT_UNPACKSTRING \
	4748	assert(pat); assert(patend); assert(s); assert(strend)
	4749
	4750	PERL_CALLCONV void Perl_unshare_hek(pTHX_ HEK* hek);
	4751	PERL_CALLCONV void Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash);
	4752	PERL_CALLCONV SV* Perl_upg_version(pTHX_ SV *ver, bool qv)
	4753	__attribute__nonnull__(pTHX_1);
	4754	#define PERL_ARGS_ASSERT_UPG_VERSION \
	4755	assert(ver)
	4756
	4757	PERL_CALLCONV U8* Perl_utf16_to_utf8(pTHX_ U8* p, U8 d, I32 bytelen, I32 newlen)
	4758	__attribute__nonnull__(pTHX_1)
	4759	__attribute__nonnull__(pTHX_2)
	4760	__attribute__nonnull__(pTHX_4);
	4761	#define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \
	4762	assert(p); assert(d); assert(newlen)
	4763
	4764	PERL_CALLCONV U8* Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 d, I32 bytelen, I32 newlen)
	4765	__attribute__nonnull__(pTHX_1)
	4766	__attribute__nonnull__(pTHX_2)
	4767	__attribute__nonnull__(pTHX_4);
	4768	#define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \
	4769	assert(p); assert(d); assert(newlen)
	4770
	4771	PERL_CALLCONV IV Perl_utf8_distance(pTHX_ const U8 a, const U8 b)
	4772	__attribute__warn_unused_result__
	4773	__attribute__pure__
	4774	__attribute__nonnull__(pTHX_1)
	4775	__attribute__nonnull__(pTHX_2);
	4776	#define PERL_ARGS_ASSERT_UTF8_DISTANCE \
	4777	assert(a); assert(b)
	4778
	4779	PERL_CALLCONV U8* Perl_utf8_hop(pTHX_ const U8 *s, I32 off)
	4780	__attribute__warn_unused_result__
	4781	__attribute__pure__
	4782	__attribute__nonnull__(pTHX_1);
	4783	#define PERL_ARGS_ASSERT_UTF8_HOP \
	4784	assert(s)
	4785
	4786	PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e)
	4787	__attribute__warn_unused_result__
	4788	__attribute__pure__
	4789	__attribute__nonnull__(pTHX_1)
	4790	__attribute__nonnull__(pTHX_2);
	4791	#define PERL_ARGS_ASSERT_UTF8_LENGTH \
	4792	assert(s); assert(e)
	4793
	4794	PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 s, STRLEN len)
	4795	__attribute__nonnull__(pTHX_1)
	4796	__attribute__nonnull__(pTHX_2);
	4797	#define PERL_ARGS_ASSERT_UTF8_TO_BYTES \
	4798	assert(s); assert(len)
	4799
	4800	PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 s, STRLEN retlen)
	4801	__attribute__deprecated__
	4802	__attribute__nonnull__(pTHX_1);
	4803	#define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \
	4804	assert(s)
	4805
	4806	/* PERL_CALLCONV UV utf8_to_uvchr_buf(pTHX_ const U8 s, const U8 send, STRLEN *retlen)
	4807	__attribute__nonnull__(pTHX_1)
	4808	__attribute__nonnull__(pTHX_2); */
	4809
	4810	PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 s, STRLEN retlen)
	4811	__attribute__deprecated__
	4812	__attribute__nonnull__(pTHX_1);
	4813	#define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \
	4814	assert(s)
	4815
	4816	PERL_CALLCONV UV Perl_utf8_to_uvuni_buf(pTHX_ const U8 s, const U8 send, STRLEN *retlen)
	4817	__attribute__deprecated__
	4818	__attribute__nonnull__(pTHX_1)
	4819	__attribute__nonnull__(pTHX_2);
	4820	#define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF \
	4821	assert(s); assert(send)
	4822
	4823	PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 s, STRLEN curlen, STRLEN retlen, U32 flags)
	4824	__attribute__nonnull__(pTHX_1);
	4825	#define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \
	4826	assert(s)
	4827
	4828	PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 s, STRLEN curlen, STRLEN retlen, U32 flags)
	4829	__attribute__nonnull__(pTHX_1);
	4830	#define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \
	4831	assert(s)
	4832
	4833	/* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv)
	4834	__attribute__nonnull__(pTHX_1); */
	4835
	4836	/* PERL_CALLCONV U8* uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
	4837	__attribute__nonnull__(pTHX_1); */
	4838
	4839	PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
	4840	__attribute__nonnull__(pTHX_1);
	4841	#define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \
	4842	assert(d)
	4843
	4844	PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
	4845	__attribute__nonnull__(pTHX_1);
	4846	#define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \
	4847	assert(d)
	4848
	4849	PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
	4850	__attribute__nonnull__(pTHX_1);
	4851	#define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \
	4852	assert(d)
	4853
	4854	PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 s, STRLEN retlen)
	4855	__attribute__nonnull__(pTHX_1);
	4856	#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \
	4857	assert(s)
	4858
	4859	PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 s, STRLEN retlen)
	4860	__attribute__deprecated__
	4861	__attribute__nonnull__(pTHX_1);
	4862	#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \
	4863	assert(s)
	4864
	4865	PERL_CALLCONV bool Perl_validate_proto(pTHX_ SV name, SV proto, bool warn)
	4866	__attribute__nonnull__(pTHX_1);
	4867	#define PERL_ARGS_ASSERT_VALIDATE_PROTO \
	4868	assert(name)
	4869
	4870	PERL_CALLCONV int Perl_vcmp(pTHX_ SV lhv, SV rhv)
	4871	__attribute__nonnull__(pTHX_1)
	4872	__attribute__nonnull__(pTHX_2);
	4873	#define PERL_ARGS_ASSERT_VCMP \
	4874	assert(lhv); assert(rhv)
	4875
	4876	PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char* pat, va_list* args)
	4877	__attribute__noreturn__;
	4878
	4879	PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args)
	4880	__attribute__nonnull__(pTHX_1);
	4881	#define PERL_ARGS_ASSERT_VDEB \
	4882	assert(pat)
	4883
	4884	PERL_CALLCONV char* Perl_vform(pTHX_ const char* pat, va_list* args)
	4885	__attribute__nonnull__(pTHX_1);
	4886	#define PERL_ARGS_ASSERT_VFORM \
	4887	assert(pat)
	4888
	4889	PERL_CALLCONV void Perl_vivify_defelem(pTHX_ SV* sv)
	4890	__attribute__nonnull__(pTHX_1);
	4891	#define PERL_ARGS_ASSERT_VIVIFY_DEFELEM \
	4892	assert(sv)
	4893
	4894	PERL_CALLCONV SV* Perl_vivify_ref(pTHX_ SV* sv, U32 to_what)
	4895	__attribute__warn_unused_result__
	4896	__attribute__nonnull__(pTHX_1);
	4897	#define PERL_ARGS_ASSERT_VIVIFY_REF \
	4898	assert(sv)
	4899
	4900	PERL_CALLCONV void Perl_vload_module(pTHX_ U32 flags, SV* name, SV* ver, va_list* args)
	4901	__attribute__nonnull__(pTHX_2);
	4902	#define PERL_ARGS_ASSERT_VLOAD_MODULE \
	4903	assert(name)
	4904
	4905	PERL_CALLCONV SV* Perl_vmess(pTHX_ const char* pat, va_list* args)
	4906	__attribute__nonnull__(pTHX_1);
	4907	#define PERL_ARGS_ASSERT_VMESS \
	4908	assert(pat)
	4909
	4910	PERL_CALLCONV SV* Perl_vnewSVpvf(pTHX_ const char const pat, va_list const args)
	4911	__attribute__malloc__
	4912	__attribute__warn_unused_result__
	4913	__attribute__nonnull__(pTHX_1);
	4914	#define PERL_ARGS_ASSERT_VNEWSVPVF \
	4915	assert(pat)
	4916
	4917	PERL_CALLCONV SV* Perl_vnormal(pTHX_ SV *vs)
	4918	__attribute__nonnull__(pTHX_1);
	4919	#define PERL_ARGS_ASSERT_VNORMAL \
	4920	assert(vs)
	4921
	4922	PERL_CALLCONV SV* Perl_vnumify(pTHX_ SV *vs)
	4923	__attribute__nonnull__(pTHX_1);
	4924	#define PERL_ARGS_ASSERT_VNUMIFY \
	4925	assert(vs)
	4926
	4927	PERL_CALLCONV SV* Perl_vstringify(pTHX_ SV *vs)
	4928	__attribute__nonnull__(pTHX_1);
	4929	#define PERL_ARGS_ASSERT_VSTRINGIFY \
	4930	assert(vs)
	4931
	4932	PERL_CALLCONV SV* Perl_vverify(pTHX_ SV *vs)
	4933	__attribute__nonnull__(pTHX_1);
	4934	#define PERL_ARGS_ASSERT_VVERIFY \
	4935	assert(vs)
	4936
	4937	PERL_CALLCONV void Perl_vwarn(pTHX_ const char* pat, va_list* args)
	4938	__attribute__nonnull__(pTHX_1);
	4939	#define PERL_ARGS_ASSERT_VWARN \
	4940	assert(pat)
	4941
	4942	PERL_CALLCONV void Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args)
	4943	__attribute__nonnull__(pTHX_2);
	4944	#define PERL_ARGS_ASSERT_VWARNER \
	4945	assert(pat)
	4946
	4947	PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int* statusp, int flags)
	4948	__attribute__nonnull__(pTHX_2);
	4949	#define PERL_ARGS_ASSERT_WAIT4PID \
	4950	assert(statusp)
	4951
	4952	PERL_CALLCONV void Perl_warn(pTHX_ const char* pat, ...)
	4953	__attribute__format__(__printf__,pTHX_1,pTHX_2)
	4954	__attribute__nonnull__(pTHX_1);
	4955	#define PERL_ARGS_ASSERT_WARN \
	4956	assert(pat)
	4957
	4958	PERL_CALLCONV void Perl_warn_sv(pTHX_ SV *baseex)
	4959	__attribute__nonnull__(pTHX_1);
	4960	#define PERL_ARGS_ASSERT_WARN_SV \
	4961	assert(baseex)
	4962
	4963	PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char* pat, ...)
	4964	__attribute__format__(__printf__,pTHX_2,pTHX_3)
	4965	__attribute__nonnull__(pTHX_2);
	4966	#define PERL_ARGS_ASSERT_WARNER \
	4967	assert(pat)
	4968
	4969	PERL_CALLCONV I32 Perl_was_lvalue_sub(pTHX)
	4970	__attribute__warn_unused_result__;
	4971
	4972	PERL_CALLCONV void Perl_watch(pTHX_ char** addr)
	4973	__attribute__nonnull__(pTHX_1);
	4974	#define PERL_ARGS_ASSERT_WATCH \
	4975	assert(addr)
	4976
	4977	/* PERL_CALLCONV I32 whichsig(pTHX_ const char* sig)
	4978	__attribute__nonnull__(pTHX_1); */
	4979
	4980	PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char* sig)
	4981	__attribute__nonnull__(pTHX_1);
	4982	#define PERL_ARGS_ASSERT_WHICHSIG_PV \
	4983	assert(sig)
	4984
	4985	PERL_CALLCONV I32 Perl_whichsig_pvn(pTHX_ const char* sig, STRLEN len)
	4986	__attribute__nonnull__(pTHX_1);
	4987	#define PERL_ARGS_ASSERT_WHICHSIG_PVN \
	4988	assert(sig)
	4989
	4990	PERL_CALLCONV I32 Perl_whichsig_sv(pTHX_ SV* sigsv)
	4991	__attribute__nonnull__(pTHX_1);
	4992	#define PERL_ARGS_ASSERT_WHICHSIG_SV \
	4993	assert(sigsv)
	4994
	4995	PERL_CALLCONV void Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p)
	4996	__attribute__nonnull__(pTHX_2)
	4997	__attribute__nonnull__(pTHX_3);
	4998	#define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \
	4999	assert(new_checker); assert(old_checker_p)
	5000
	5001	PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV* msv)
	5002	__attribute__nonnull__(pTHX_1);
	5003	#define PERL_ARGS_ASSERT_WRITE_TO_STDERR \
	5004	assert(msv)
	5005
	5006	PERL_CALLCONV void Perl_xs_apiversion_bootcheck(pTHX_ SV module, const char api_p, STRLEN api_len)
	5007	__attribute__nonnull__(pTHX_1)
	5008	__attribute__nonnull__(pTHX_2);
	5009	#define PERL_ARGS_ASSERT_XS_APIVERSION_BOOTCHECK \
	5010	assert(module); assert(api_p)
	5011
	5012	PERL_CALLCONV void Perl_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len)
	5013	__attribute__nonnull__(pTHX_3);
	5014	#define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \
	5015	assert(xs_p)
	5016
	5017	PERL_CALLCONV int Perl_yyerror(pTHX_ const char *const s)
	5018	__attribute__nonnull__(pTHX_1);
	5019	#define PERL_ARGS_ASSERT_YYERROR \
	5020	assert(s)
	5021
	5022	PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char *const s, U32 flags)
	5023	__attribute__nonnull__(pTHX_1);
	5024	#define PERL_ARGS_ASSERT_YYERROR_PV \
	5025	assert(s)
	5026
	5027	PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char *const s, STRLEN len, U32 flags)
	5028	__attribute__nonnull__(pTHX_1);
	5029	#define PERL_ARGS_ASSERT_YYERROR_PVN \
	5030	assert(s)
	5031
	5032	PERL_CALLCONV int Perl_yylex(pTHX);
	5033	PERL_CALLCONV int Perl_yyparse(pTHX_ int gramtype);
	5034	PERL_CALLCONV void Perl_yyunlex(pTHX);
	5035	#if !(defined(DEBUGGING))
	5036	# if !defined(NV_PRESERVES_UV)
	5037	# if defined(PERL_IN_SV_C)
	5038	STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv)
	5039	__attribute__nonnull__(pTHX_1);
	5040	#define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \
	5041	assert(sv)
	5042
	5043	# endif
	5044	# endif
	5045	#endif
	5046	#if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO))
	5047	PERL_CALLCONV Signal_t Perl_csighandler(int sig);
	5048	PERL_CALLCONV Signal_t Perl_sighandler(int sig);
	5049	#endif
	5050	#if !(defined(NO_MATHOMS))
	5051	PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv);
	5052	#endif
	5053	#if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION))
	5054	PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd)
	5055	__attribute__nonnull__(pTHX_1);
	5056	#define PERL_ARGS_ASSERT_DO_EXEC \
	5057	assert(cmd)
	5058
	5059	#endif
	5060	#if !(defined(PERL_GLOBAL_STRUCT_PRIVATE))
	5061	# if defined(PERL_IMPLICIT_CONTEXT)
	5062	PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size)
	5063	__attribute__nonnull__(pTHX_1);
	5064	#define PERL_ARGS_ASSERT_MY_CXT_INIT \
	5065	assert(index)
	5066
	5067	# endif
	5068	#endif
	5069	#if !(defined(PERL_MAD))
	5070	PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
	5071	PERL_CALLCONV void Perl_package(pTHX_ OP* o)
	5072	__attribute__nonnull__(pTHX_1);
	5073	#define PERL_ARGS_ASSERT_PACKAGE \
	5074	assert(o)
	5075
	5076	PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg)
	5077	__attribute__nonnull__(pTHX_4);
	5078	#define PERL_ARGS_ASSERT_UTILIZE \
	5079	assert(idop)
	5080
	5081	#endif
	5082	#if !(defined(_MSC_VER))
	5083	PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
	5084	__attribute__noreturn__
	5085	__attribute__nonnull__(pTHX_1)
	5086	__attribute__nonnull__(pTHX_2);
	5087	#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \
	5088	assert(sv); assert(mg)
	5089
	5090	#endif
	5091	#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
	5092	PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len)
	5093	__attribute__nonnull__(1);
	5094	#define PERL_ARGS_ASSERT_MY_BZERO \
	5095	assert(loc)
	5096
	5097	#endif
	5098	#if !defined(HAS_GETENV_LEN)
	5099	PERL_CALLCONV char* Perl_getenv_len(pTHX_ const char env_elem, unsigned long len)
	5100	__attribute__nonnull__(pTHX_1)
	5101	__attribute__nonnull__(pTHX_2);
	5102	#define PERL_ARGS_ASSERT_GETENV_LEN \
	5103	assert(env_elem); assert(len)
	5104
	5105	#endif
	5106	#if !defined(HAS_MEMCMP) \|\| !defined(HAS_SANE_MEMCMP)
	5107	PERL_CALLCONV I32 Perl_my_memcmp(const char* s1, const char* s2, I32 len)
	5108	__attribute__pure__
	5109	__attribute__nonnull__(1)
	5110	__attribute__nonnull__(2);
	5111	#define PERL_ARGS_ASSERT_MY_MEMCMP \
	5112	assert(s1); assert(s2)
	5113
	5114	#endif
	5115	#if !defined(HAS_MEMSET)
	5116	PERL_CALLCONV void* Perl_my_memset(char* loc, I32 ch, I32 len)
	5117	__attribute__nonnull__(1);
	5118	#define PERL_ARGS_ASSERT_MY_MEMSET \
	5119	assert(loc)
	5120
	5121	#endif
	5122	#if !defined(HAS_MKDIR) \|\| !defined(HAS_RMDIR)
	5123	# if defined(PERL_IN_PP_SYS_C)
	5124	STATIC int S_dooneliner(pTHX_ const char cmd, const char filename)
	5125	__attribute__warn_unused_result__
	5126	__attribute__nonnull__(pTHX_1)
	5127	__attribute__nonnull__(pTHX_2);
	5128	#define PERL_ARGS_ASSERT_DOONELINER \
	5129	assert(cmd); assert(filename)
	5130
	5131	# endif
	5132	#endif
	5133	#if !defined(HAS_RENAME)
	5134	PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char* a, const char* b)
	5135	__attribute__nonnull__(pTHX_1)
	5136	__attribute__nonnull__(pTHX_2);
	5137	#define PERL_ARGS_ASSERT_SAME_DIRENT \
	5138	assert(a); assert(b)
	5139
	5140	#endif
	5141	#if !defined(HAS_SIGNBIT)
	5142	PERL_CALLCONV int Perl_signbit(NV f)
	5143	__attribute__pure__;
	5144
	5145	#endif
	5146	#if !defined(HAS_STRLCAT)
	5147	PERL_CALLCONV Size_t Perl_my_strlcat(char dst, const char src, Size_t size);
	5148	#endif
	5149	#if !defined(HAS_STRLCPY)
	5150	PERL_CALLCONV Size_t Perl_my_strlcpy(char dst, const char src, Size_t size);
	5151	#endif
	5152	#if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP)
	5153	PERL_CALLCONV I32 Perl_my_chsize(pTHX_ int fd, Off_t length)
	5154	__attribute__warn_unused_result__;
	5155
	5156	#endif
	5157	#if !defined(NV_PRESERVES_UV)
	5158	# if defined(DEBUGGING)
	5159	# if defined(PERL_IN_SV_C)
	5160	STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv, I32 numtype)
	5161	__attribute__nonnull__(pTHX_1);
	5162	#define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \
	5163	assert(sv)
	5164
	5165	# endif
	5166	# endif
	5167	#endif
	5168	#if !defined(PERL_DISABLE_PMC)
	5169	# if defined(PERL_IN_PP_CTL_C)
	5170	STATIC PerlIO * S_doopen_pm(pTHX_ SV *name)
	5171	__attribute__warn_unused_result__
	5172	__attribute__nonnull__(pTHX_1);
	5173	#define PERL_ARGS_ASSERT_DOOPEN_PM \
	5174	assert(name)
	5175
	5176	# endif
	5177	#endif
	5178	#if !defined(PERL_IMPLICIT_SYS)
	5179	PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr);
	5180	PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode)
	5181	__attribute__nonnull__(pTHX_1)
	5182	__attribute__nonnull__(pTHX_2);
	5183	#define PERL_ARGS_ASSERT_MY_POPEN \
	5184	assert(cmd); assert(mode)
	5185
	5186	#endif
	5187	#if !defined(PERL_IS_MINIPERL)
	5188	# if defined(PERL_IN_PERL_C)
	5189	STATIC SV * S_incpush_if_exists(pTHX_ AV const av, SV dir, SV *const stem)
	5190	__attribute__nonnull__(pTHX_1)
	5191	__attribute__nonnull__(pTHX_2)
	5192	__attribute__nonnull__(pTHX_3);
	5193	#define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \
	5194	assert(av); assert(dir); assert(stem)
	5195
	5196	# endif
	5197	#endif
	5198	#if !defined(PERL_NO_UTF16_FILTER)
	5199	# if defined(PERL_IN_TOKE_C)
	5200	STATIC U8* S_add_utf16_textfilter(pTHX_ U8 *const s, bool reversed)
	5201	__attribute__nonnull__(pTHX_1);
	5202	#define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \
	5203	assert(s)
	5204
	5205	STATIC I32 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen)
	5206	__attribute__nonnull__(pTHX_2);
	5207	#define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \
	5208	assert(sv)
	5209
	5210	# endif
	5211	#endif
	5212	#if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW)
	5213	# if defined(PERL_IN_PERL_C)
	5214	STATIC void S_validate_suid(pTHX_ PerlIO *rsfp)
	5215	__attribute__nonnull__(pTHX_1);
	5216	#define PERL_ARGS_ASSERT_VALIDATE_SUID \
	5217	assert(rsfp)
	5218
	5219	# endif
	5220	#endif
	5221	#if !defined(SPRINTF_RETURNS_STRLEN)
	5222	PERL_CALLCONV int Perl_my_sprintf(char buffer, const char pat, ...)
	5223	__attribute__nonnull__(1)
	5224	__attribute__nonnull__(2);
	5225	#define PERL_ARGS_ASSERT_MY_SPRINTF \
	5226	assert(buffer); assert(pat)
	5227
	5228	#endif
	5229	#if !defined(WIN32)
	5230	PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report)
	5231	__attribute__nonnull__(pTHX_1);
	5232	#define PERL_ARGS_ASSERT_DO_EXEC3 \
	5233	assert(incmd)
	5234
	5235	#endif
	5236	#if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) \|\| (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY))
	5237	PERL_CALLCONV char* Perl_my_bcopy(const char* from, char* to, I32 len)
	5238	__attribute__nonnull__(1)
	5239	__attribute__nonnull__(2);
	5240	#define PERL_ARGS_ASSERT_MY_BCOPY \
	5241	assert(from); assert(to)
	5242
	5243	#endif
	5244	#if defined(DEBUGGING)
	5245	PERL_CALLCONV int Perl_get_debug_opts(pTHX_ const char **s, bool givehelp)
	5246	__attribute__warn_unused_result__
	5247	__attribute__nonnull__(pTHX_1);
	5248	#define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \
	5249	assert(s)
	5250
	5251	PERL_CALLCONV void Perl_hv_assert(pTHX_ HV *hv)
	5252	__attribute__nonnull__(pTHX_1);
	5253	#define PERL_ARGS_ASSERT_HV_ASSERT \
	5254	assert(hv)
	5255
	5256	PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv)
	5257	__attribute__nonnull__(pTHX_2);
	5258	#define PERL_ARGS_ASSERT_PAD_SETSV \
	5259	assert(sv)
	5260
	5261	PERL_CALLCONV SV* Perl_pad_sv(pTHX_ PADOFFSET po);
	5262	# if defined(PERL_IN_PAD_C)
	5263	STATIC void S_cv_dump(pTHX_ const CV cv, const char title)
	5264	__attribute__nonnull__(pTHX_1)
	5265	__attribute__nonnull__(pTHX_2);
	5266	#define PERL_ARGS_ASSERT_CV_DUMP \
	5267	assert(cv); assert(title)
	5268
	5269	# endif
	5270	# if defined(PERL_IN_REGCOMP_C)
	5271	STATIC void S_dump_trie(pTHX_ const struct _reg_trie_data trie, HV widecharmap, AV *revcharmap, U32 depth)
	5272	__attribute__nonnull__(pTHX_1)
	5273	__attribute__nonnull__(pTHX_3);
	5274	#define PERL_ARGS_ASSERT_DUMP_TRIE \
	5275	assert(trie); assert(revcharmap)
	5276
	5277	STATIC void S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data trie, HV widecharmap, AV *revcharmap, U32 next_alloc, U32 depth)
	5278	__attribute__nonnull__(pTHX_1)
	5279	__attribute__nonnull__(pTHX_3);
	5280	#define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \
	5281	assert(trie); assert(revcharmap)
	5282
	5283	STATIC void S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data trie, HV widecharmap, AV *revcharmap, U32 next_alloc, U32 depth)
	5284	__attribute__nonnull__(pTHX_1)
	5285	__attribute__nonnull__(pTHX_3);
	5286	#define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \
	5287	assert(trie); assert(revcharmap)
	5288
	5289	STATIC const regnode* S_dumpuntil(pTHX_ const regexp r, const regnode start, const regnode node, const regnode last, const regnode plast, SV sv, I32 indent, U32 depth)
	5290	__attribute__nonnull__(pTHX_1)
	5291	__attribute__nonnull__(pTHX_2)
	5292	__attribute__nonnull__(pTHX_3)
	5293	__attribute__nonnull__(pTHX_6);
	5294	#define PERL_ARGS_ASSERT_DUMPUNTIL \
	5295	assert(r); assert(start); assert(node); assert(sv)
	5296
	5297	STATIC void S_put_byte(pTHX_ SV* sv, int c)
	5298	__attribute__nonnull__(pTHX_1);
	5299	#define PERL_ARGS_ASSERT_PUT_BYTE \
	5300	assert(sv)
	5301
	5302	STATIC bool S_put_latin1_charclass_innards(pTHX_ SV* sv, char* bitmap)
	5303	__attribute__nonnull__(pTHX_1)
	5304	__attribute__nonnull__(pTHX_2);
	5305	#define PERL_ARGS_ASSERT_PUT_LATIN1_CHARCLASS_INNARDS \
	5306	assert(sv); assert(bitmap)
	5307
	5308	STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags);
	5309	STATIC void S_regdump_intflags(pTHX_ const char *lead, const U32 flags);
	5310	STATIC U8 S_regtail_study(pTHX_ RExC_state_t pRExC_state, regnode p, const regnode *val, U32 depth)
	5311	__attribute__nonnull__(pTHX_1)
	5312	__attribute__nonnull__(pTHX_2)
	5313	__attribute__nonnull__(pTHX_3);
	5314	#define PERL_ARGS_ASSERT_REGTAIL_STUDY \
	5315	assert(pRExC_state); assert(p); assert(val)
	5316
	5317	# endif
	5318	# if defined(PERL_IN_REGEXEC_C)
	5319	STATIC void S_debug_start_match(pTHX_ const REGEXP prog, const bool do_utf8, const char start, const char end, const char blurb)
	5320	__attribute__nonnull__(pTHX_1)
	5321	__attribute__nonnull__(pTHX_3)
	5322	__attribute__nonnull__(pTHX_4)
	5323	__attribute__nonnull__(pTHX_5);
	5324	#define PERL_ARGS_ASSERT_DEBUG_START_MATCH \
	5325	assert(prog); assert(start); assert(end); assert(blurb)
	5326
	5327	STATIC void S_dump_exec_pos(pTHX_ const char locinput, const regnode scan, const char loc_regeol, const char loc_bostr, const char *loc_reg_starttry, const bool do_utf8)
	5328	__attribute__nonnull__(pTHX_1)
	5329	__attribute__nonnull__(pTHX_2)
	5330	__attribute__nonnull__(pTHX_3)
	5331	__attribute__nonnull__(pTHX_4)
	5332	__attribute__nonnull__(pTHX_5);
	5333	#define PERL_ARGS_ASSERT_DUMP_EXEC_POS \
	5334	assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); assert(loc_reg_starttry)
	5335
	5336	# endif
	5337	# if defined(PERL_IN_SV_C)
	5338	STATIC void S_del_sv(pTHX_ SV *p)
	5339	__attribute__nonnull__(pTHX_1);
	5340	#define PERL_ARGS_ASSERT_DEL_SV \
	5341	assert(p)
	5342
	5343	# endif
	5344	# if defined(PERL_IN_TOKE_C)
	5345	STATIC void S_printbuf(pTHX_ const char const fmt, const char const s)
	5346	__attribute__format__(__printf__,pTHX_1,0)
	5347	__attribute__nonnull__(pTHX_1)
	5348	__attribute__nonnull__(pTHX_2);
	5349	#define PERL_ARGS_ASSERT_PRINTBUF \
	5350	assert(fmt); assert(s)
	5351
	5352	STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE* lvalp)
	5353	__attribute__nonnull__(pTHX_2);
	5354	#define PERL_ARGS_ASSERT_TOKEREPORT \
	5355	assert(lvalp)
	5356
	5357	# endif
	5358	#endif
	5359	#if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP)
	5360	PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv)
	5361	__attribute__nonnull__(pTHX_1);
	5362	#define PERL_ARGS_ASSERT_DUMP_SV_CHILD \
	5363	assert(sv)
	5364
	5365	#endif
	5366	#if defined(HAS_MSG) \|\| defined(HAS_SEM) \|\| defined(HAS_SHM)
	5367	PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV mark, SV sp)
	5368	__attribute__nonnull__(pTHX_2)
	5369	__attribute__nonnull__(pTHX_3);
	5370	#define PERL_ARGS_ASSERT_DO_IPCCTL \
	5371	assert(mark); assert(sp)
	5372
	5373	PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV mark, SV sp)
	5374	__attribute__nonnull__(pTHX_2)
	5375	__attribute__nonnull__(pTHX_3);
	5376	#define PERL_ARGS_ASSERT_DO_IPCGET \
	5377	assert(mark); assert(sp)
	5378
	5379	PERL_CALLCONV I32 Perl_do_msgrcv(pTHX_ SV mark, SV sp)
	5380	__attribute__nonnull__(pTHX_1)
	5381	__attribute__nonnull__(pTHX_2);
	5382	#define PERL_ARGS_ASSERT_DO_MSGRCV \
	5383	assert(mark); assert(sp)
	5384
	5385	PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV mark, SV sp)
	5386	__attribute__nonnull__(pTHX_1)
	5387	__attribute__nonnull__(pTHX_2);
	5388	#define PERL_ARGS_ASSERT_DO_MSGSND \
	5389	assert(mark); assert(sp)
	5390
	5391	PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV mark, SV sp)
	5392	__attribute__nonnull__(pTHX_1)
	5393	__attribute__nonnull__(pTHX_2);
	5394	#define PERL_ARGS_ASSERT_DO_SEMOP \
	5395	assert(mark); assert(sp)
	5396
	5397	PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV mark, SV sp)
	5398	__attribute__nonnull__(pTHX_2)
	5399	__attribute__nonnull__(pTHX_3);
	5400	#define PERL_ARGS_ASSERT_DO_SHMIO \
	5401	assert(mark); assert(sp)
	5402
	5403	#endif
	5404	#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
	5405	PERL_CALLCONV Signal_t Perl_csighandler(int sig, siginfo_t info, void uap);
	5406	PERL_CALLCONV Signal_t Perl_sighandler(int sig, siginfo_t info, void uap);
	5407	#endif
	5408	#if defined(HAVE_INTERP_INTERN)
	5409	PERL_CALLCONV void Perl_sys_intern_clear(pTHX);
	5410	PERL_CALLCONV void Perl_sys_intern_init(pTHX);
	5411	# if defined(USE_ITHREADS)
	5412	PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst)
	5413	__attribute__nonnull__(pTHX_1)
	5414	__attribute__nonnull__(pTHX_2);
	5415	#define PERL_ARGS_ASSERT_SYS_INTERN_DUP \
	5416	assert(src); assert(dst)
	5417
	5418	# endif
	5419	#endif
	5420	#if defined(MYMALLOC)
	5421	PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char* s)
	5422	__attribute__nonnull__(pTHX_1);
	5423	#define PERL_ARGS_ASSERT_DUMP_MSTATS \
	5424	assert(s)
	5425
	5426	PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level)
	5427	__attribute__nonnull__(pTHX_1);
	5428	#define PERL_ARGS_ASSERT_GET_MSTATS \
	5429	assert(buf)
	5430
	5431	PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes)
	5432	__attribute__warn_unused_result__;
	5433
	5434	PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p)
	5435	__attribute__warn_unused_result__
	5436	__attribute__nonnull__(1);
	5437	#define PERL_ARGS_ASSERT_MALLOCED_SIZE \
	5438	assert(p)
	5439
	5440	#endif
	5441	#if defined(NO_MATHOMS)
	5442	/* PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV sv); /
	5443	#endif
	5444	#if defined(PERL_ANY_COW)
	5445	PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr)
	5446	__attribute__nonnull__(pTHX_2);
	5447	#define PERL_ARGS_ASSERT_SV_SETSV_COW \
	5448	assert(sstr)
	5449
	5450	#endif
	5451	#if defined(PERL_CORE)
	5452	PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab)
	5453	__attribute__nonnull__(pTHX_1);
	5454	#define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \
	5455	assert(slab)
	5456
	5457	PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab)
	5458	__attribute__nonnull__(pTHX_1);
	5459	#define PERL_ARGS_ASSERT_OPSLAB_FREE \
	5460	assert(slab)
	5461
	5462	PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab)
	5463	__attribute__nonnull__(pTHX_1);
	5464	#define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \
	5465	assert(slab)
	5466
	5467	PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser parser, OPSLAB slab)
	5468	__attribute__nonnull__(pTHX_1)
	5469	__attribute__nonnull__(pTHX_2);
	5470	#define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \
	5471	assert(parser); assert(slab)
	5472
	5473	# if defined(PERL_DEBUG_READONLY_OPS)
	5474	PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab)
	5475	__attribute__nonnull__(pTHX_1);
	5476	#define PERL_ARGS_ASSERT_SLAB_TO_RO \
	5477	assert(slab)
	5478
	5479	PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB *const slab)
	5480	__attribute__nonnull__(pTHX_1);
	5481	#define PERL_ARGS_ASSERT_SLAB_TO_RW \
	5482	assert(slab)
	5483
	5484	# endif
	5485	#endif
	5486	#if defined(PERL_CORE) \|\| defined (PERL_EXT)
	5487	PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV sv, const char pv, STRLEN pos, STRLEN *lenp)
	5488	__attribute__nonnull__(pTHX_1)
	5489	__attribute__nonnull__(pTHX_2);
	5490	#define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \
	5491	assert(sv); assert(pv)
	5492
	5493	#endif
	5494	#if defined(PERL_CR_FILTER)
	5495	# if defined(PERL_IN_TOKE_C)
	5496	STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen);
	5497	STATIC void S_strip_return(pTHX_ SV *sv)
	5498	__attribute__nonnull__(pTHX_1);
	5499	#define PERL_ARGS_ASSERT_STRIP_RETURN \
	5500	assert(sv)
	5501
	5502	# endif
	5503	#endif
	5504	#if defined(PERL_DEBUG_READONLY_OPS)
	5505	PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o)
	5506	__attribute__nonnull__(pTHX_1);
	5507	#define PERL_ARGS_ASSERT_OP_REFCNT_DEC \
	5508	assert(o)
	5509
	5510	PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o);
	5511	#endif
	5512	#if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)
	5513	/* PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd)
	5514	__attribute__nonnull__(pTHX_1); */
	5515
	5516	#endif
	5517	#if defined(PERL_DONT_CREATE_GVSV)
	5518	/* PERL_CALLCONV GV* Perl_gv_SVadd(pTHX_ GV gv); /
	5519	#endif
	5520	#if defined(PERL_GLOBAL_STRUCT)
	5521	PERL_CALLCONV struct perl_vars * Perl_GetVars(pTHX);
	5522	PERL_CALLCONV void Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp)
	5523	__attribute__nonnull__(pTHX_1);
	5524	#define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT \
	5525	assert(plvarsp)
	5526
	5527	PERL_CALLCONV struct perl_vars* Perl_init_global_struct(pTHX);
	5528	#endif
	5529	#if defined(PERL_GLOBAL_STRUCT_PRIVATE)
	5530	# if defined(PERL_IMPLICIT_CONTEXT)
	5531	PERL_CALLCONV int Perl_my_cxt_index(pTHX_ const char *my_cxt_key)
	5532	__attribute__nonnull__(pTHX_1);
	5533	#define PERL_ARGS_ASSERT_MY_CXT_INDEX \
	5534	assert(my_cxt_key)
	5535
	5536	PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size)
	5537	__attribute__nonnull__(pTHX_1);
	5538	#define PERL_ARGS_ASSERT_MY_CXT_INIT \
	5539	assert(my_cxt_key)
	5540
	5541	# endif
	5542	#endif
	5543	#if defined(PERL_IMPLICIT_CONTEXT)
	5544	PERL_CALLCONV_NO_RET void Perl_croak_nocontext(const char* pat, ...)
	5545	__attribute__noreturn__
	5546	__attribute__format__null_ok__(__printf__,1,2);
	5547
	5548	PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...)
	5549	__attribute__format__(__printf__,1,2)
	5550	__attribute__nonnull__(1);
	5551	#define PERL_ARGS_ASSERT_DEB_NOCONTEXT \
	5552	assert(pat)
	5553
	5554	PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...)
	5555	__attribute__format__null_ok__(__printf__,1,2);
	5556
	5557	PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...)
	5558	__attribute__format__(__printf__,1,2)
	5559	__attribute__nonnull__(1);
	5560	#define PERL_ARGS_ASSERT_FORM_NOCONTEXT \
	5561	assert(pat)
	5562
	5563	PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO stream, const char format, ...)
	5564	__attribute__format__(__printf__,2,3)
	5565	__attribute__nonnull__(1)
	5566	__attribute__nonnull__(2);
	5567	#define PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT \
	5568	assert(stream); assert(format)
	5569
	5570	PERL_CALLCONV void Perl_load_module_nocontext(U32 flags, SV* name, SV* ver, ...)
	5571	__attribute__nonnull__(2);
	5572	#define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \
	5573	assert(name)
	5574
	5575	PERL_CALLCONV SV* Perl_mess_nocontext(const char* pat, ...)
	5576	__attribute__format__(__printf__,1,2)
	5577	__attribute__nonnull__(1);
	5578	#define PERL_ARGS_ASSERT_MESS_NOCONTEXT \
	5579	assert(pat)
	5580
	5581	PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char *const pat, ...)
	5582	__attribute__format__(__printf__,1,2)
	5583	__attribute__nonnull__(1);
	5584	#define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \
	5585	assert(pat)
	5586
	5587	PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...)
	5588	__attribute__format__(__printf__,1,2)
	5589	__attribute__nonnull__(1);
	5590	#define PERL_ARGS_ASSERT_PRINTF_NOCONTEXT \
	5591	assert(format)
	5592
	5593	PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV const sv, const char const pat, ...)
	5594	__attribute__format__(__printf__,2,3)
	5595	__attribute__nonnull__(1)
	5596	__attribute__nonnull__(2);
	5597	#define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \
	5598	assert(sv); assert(pat)
	5599
	5600	PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV const sv, const char const pat, ...)
	5601	__attribute__format__(__printf__,2,3)
	5602	__attribute__nonnull__(1)
	5603	__attribute__nonnull__(2);
	5604	#define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \
	5605	assert(sv); assert(pat)
	5606
	5607	PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV const sv, const char const pat, ...)
	5608	__attribute__format__(__printf__,2,3)
	5609	__attribute__nonnull__(1)
	5610	__attribute__nonnull__(2);
	5611	#define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \
	5612	assert(sv); assert(pat)
	5613
	5614	PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV const sv, const char const pat, ...)
	5615	__attribute__format__(__printf__,2,3)
	5616	__attribute__nonnull__(1)
	5617	__attribute__nonnull__(2);
	5618	#define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \
	5619	assert(sv); assert(pat)
	5620
	5621	PERL_CALLCONV void Perl_warn_nocontext(const char* pat, ...)
	5622	__attribute__format__(__printf__,1,2)
	5623	__attribute__nonnull__(1);
	5624	#define PERL_ARGS_ASSERT_WARN_NOCONTEXT \
	5625	assert(pat)
	5626
	5627	PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char* pat, ...)
	5628	__attribute__format__(__printf__,2,3)
	5629	__attribute__nonnull__(2);
	5630	#define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \
	5631	assert(pat)
	5632
	5633	#endif
	5634	#if defined(PERL_IMPLICIT_SYS)
	5635	PERL_CALLCONV PerlInterpreter* perl_alloc_using(struct IPerlMem ipM, struct IPerlMem ipMS, struct IPerlMem ipMP, struct IPerlEnv ipE, struct IPerlStdIO ipStd, struct IPerlLIO ipLIO, struct IPerlDir ipD, struct IPerlSock ipS, struct IPerlProc *ipP)
	5636	__attribute__nonnull__(1)
	5637	__attribute__nonnull__(2)
	5638	__attribute__nonnull__(3)
	5639	__attribute__nonnull__(4)
	5640	__attribute__nonnull__(5)
	5641	__attribute__nonnull__(6)
	5642	__attribute__nonnull__(7)
	5643	__attribute__nonnull__(8)
	5644	__attribute__nonnull__(9);
	5645	#define PERL_ARGS_ASSERT_PERL_ALLOC_USING \
	5646	assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP)
	5647
	5648	# if defined(USE_ITHREADS)
	5649	PERL_CALLCONV PerlInterpreter* perl_clone_using(PerlInterpreter proto_perl, UV flags, struct IPerlMem ipM, struct IPerlMem* ipMS, struct IPerlMem* ipMP, struct IPerlEnv* ipE, struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO, struct IPerlDir* ipD, struct IPerlSock* ipS, struct IPerlProc* ipP)
	5650	__attribute__nonnull__(1)
	5651	__attribute__nonnull__(3)
	5652	__attribute__nonnull__(4)
	5653	__attribute__nonnull__(5)
	5654	__attribute__nonnull__(6)
	5655	__attribute__nonnull__(7)
	5656	__attribute__nonnull__(8)
	5657	__attribute__nonnull__(9)
	5658	__attribute__nonnull__(10)
	5659	__attribute__nonnull__(11);
	5660	#define PERL_ARGS_ASSERT_PERL_CLONE_USING \
	5661	assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP)
	5662
	5663	# endif
	5664	#endif
	5665	#if defined(PERL_IN_AV_C)
	5666	STATIC MAGIC* S_get_aux_mg(pTHX_ AV *av)
	5667	__attribute__nonnull__(pTHX_1);
	5668	#define PERL_ARGS_ASSERT_GET_AUX_MG \
	5669	assert(av)
	5670
	5671	#endif
	5672	#if defined(PERL_IN_DEB_C)
	5673	STATIC void S_deb_stack_n(pTHX_ SV** stack_base, I32 stack_min, I32 stack_max, I32 mark_min, I32 mark_max)
	5674	__attribute__nonnull__(pTHX_1);
	5675	#define PERL_ARGS_ASSERT_DEB_STACK_N \
	5676	assert(stack_base)
	5677
	5678	#endif
	5679	#if defined(PERL_IN_DOIO_C)
	5680	STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report)
	5681	__attribute__nonnull__(pTHX_1);
	5682	#define PERL_ARGS_ASSERT_EXEC_FAILED \
	5683	assert(cmd)
	5684
	5685	STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective)
	5686	__attribute__warn_unused_result__;
	5687
	5688	#endif
	5689	#if defined(PERL_IN_DOOP_C)
	5690	STATIC I32 S_do_trans_complex(pTHX_ SV * const sv)
	5691	__attribute__warn_unused_result__
	5692	__attribute__nonnull__(pTHX_1);
	5693	#define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \
	5694	assert(sv)
	5695
	5696	STATIC I32 S_do_trans_complex_utf8(pTHX_ SV * const sv)
	5697	__attribute__warn_unused_result__
	5698	__attribute__nonnull__(pTHX_1);
	5699	#define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX_UTF8 \
	5700	assert(sv)
	5701
	5702	STATIC I32 S_do_trans_count(pTHX_ SV * const sv)
	5703	__attribute__warn_unused_result__
	5704	__attribute__nonnull__(pTHX_1);
	5705	#define PERL_ARGS_ASSERT_DO_TRANS_COUNT \
	5706	assert(sv)
	5707
	5708	STATIC I32 S_do_trans_count_utf8(pTHX_ SV * const sv)
	5709	__attribute__warn_unused_result__
	5710	__attribute__nonnull__(pTHX_1);
	5711	#define PERL_ARGS_ASSERT_DO_TRANS_COUNT_UTF8 \
	5712	assert(sv)
	5713
	5714	STATIC I32 S_do_trans_simple(pTHX_ SV * const sv)
	5715	__attribute__warn_unused_result__
	5716	__attribute__nonnull__(pTHX_1);
	5717	#define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \
	5718	assert(sv)
	5719
	5720	STATIC I32 S_do_trans_simple_utf8(pTHX_ SV * const sv)
	5721	__attribute__warn_unused_result__
	5722	__attribute__nonnull__(pTHX_1);
	5723	#define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE_UTF8 \
	5724	assert(sv)
	5725
	5726	#endif
	5727	#if defined(PERL_IN_DUMP_C)
	5728	STATIC CV* S_deb_curcv(pTHX_ const I32 ix);
	5729	STATIC void S_debprof(pTHX_ const OP *o)
	5730	__attribute__nonnull__(pTHX_1);
	5731	#define PERL_ARGS_ASSERT_DEBPROF \
	5732	assert(o)
	5733
	5734	STATIC SV* S_pm_description(pTHX_ const PMOP *pm)
	5735	__attribute__nonnull__(pTHX_1);
	5736	#define PERL_ARGS_ASSERT_PM_DESCRIPTION \
	5737	assert(pm)
	5738
	5739	STATIC UV S_sequence_num(pTHX_ const OP *o);
	5740	# if defined(PERL_MAD)
	5741	STATIC void S_xmldump_attr(pTHX_ I32 level, PerlIO file, const char pat, ...)
	5742	__attribute__format__(__printf__,pTHX_3,pTHX_4)
	5743	__attribute__nonnull__(pTHX_2)
	5744	__attribute__nonnull__(pTHX_3);
	5745	#define PERL_ARGS_ASSERT_XMLDUMP_ATTR \
	5746	assert(file); assert(pat)
	5747
	5748	# endif
	5749	#endif
	5750	#if defined(PERL_IN_DUMP_C) \|\| defined(PERL_IN_HV_C) \|\| defined(PERL_IN_SV_C) \|\| defined(PERL_IN_SCOPE_C)
	5751	PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv)
	5752	__attribute__nonnull__(pTHX_1);
	5753	#define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \
	5754	assert(hv)
	5755
	5756	#endif
	5757	#if defined(PERL_IN_GV_C)
	5758	STATIC bool S_find_default_stash(pTHX_ HV *stash, const char name, STRLEN len, const U32 is_utf8, const I32 add, svtype sv_type)
	5759	__attribute__nonnull__(pTHX_1)
	5760	__attribute__nonnull__(pTHX_2);
	5761	#define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \
	5762	assert(stash); assert(name)
	5763
	5764	STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type)
	5765	__attribute__nonnull__(pTHX_1);
	5766	#define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \
	5767	assert(gv)
	5768
	5769	STATIC bool S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8)
	5770	__attribute__nonnull__(pTHX_1);
	5771	#define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \
	5772	assert(name)
	5773
	5774	STATIC bool S_gv_magicalize(pTHX_ GV gv, HV stash, const char *name, STRLEN len, bool addmg, svtype sv_type)
	5775	__attribute__nonnull__(pTHX_1)
	5776	__attribute__nonnull__(pTHX_2)
	5777	__attribute__nonnull__(pTHX_3);
	5778	#define PERL_ARGS_ASSERT_GV_MAGICALIZE \
	5779	assert(gv); assert(stash); assert(name)
	5780
	5781	STATIC void S_gv_magicalize_isa(pTHX_ GV *gv)
	5782	__attribute__nonnull__(pTHX_1);
	5783	#define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \
	5784	assert(gv)
	5785
	5786	STATIC void S_maybe_multimagic_gv(pTHX_ GV gv, const char name, const svtype sv_type)
	5787	__attribute__nonnull__(pTHX_1)
	5788	__attribute__nonnull__(pTHX_2);
	5789	#define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \
	5790	assert(gv); assert(name)
	5791
	5792	STATIC bool S_parse_gv_stash_name(pTHX_ HV stash, GV gv, const char *name, STRLEN len, const char *nambeg, STRLEN full_len, const U32 is_utf8, const I32 add)
	5793	__attribute__nonnull__(pTHX_1)
	5794	__attribute__nonnull__(pTHX_2)
	5795	__attribute__nonnull__(pTHX_3)
	5796	__attribute__nonnull__(pTHX_4)
	5797	__attribute__nonnull__(pTHX_5);
	5798	#define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME \
	5799	assert(stash); assert(gv); assert(name); assert(len); assert(nambeg)
	5800
	5801	STATIC HV* S_require_tie_mod(pTHX_ GV gv, const char varpv, SV* namesv, const char *methpv, const U32 flags)
	5802	__attribute__nonnull__(pTHX_1)
	5803	__attribute__nonnull__(pTHX_2)
	5804	__attribute__nonnull__(pTHX_3)
	5805	__attribute__nonnull__(pTHX_4);
	5806	#define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \
	5807	assert(gv); assert(varpv); assert(namesv); assert(methpv)
	5808
	5809	#endif
	5810	#if defined(PERL_IN_GV_C) \|\| defined(PERL_IN_SV_C) \|\| defined(PERL_IN_PAD_C) \|\| defined(PERL_IN_OP_C)
	5811	PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV const tsv, SV const sv)
	5812	__attribute__nonnull__(pTHX_1)
	5813	__attribute__nonnull__(pTHX_2);
	5814	#define PERL_ARGS_ASSERT_SV_ADD_BACKREF \
	5815	assert(tsv); assert(sv)
	5816
	5817	#endif
	5818	#if defined(PERL_IN_HV_C)
	5819	STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items)
	5820	__attribute__nonnull__(pTHX_1);
	5821	#define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \
	5822	assert(hv)
	5823
	5824	STATIC void S_hfreeentries(pTHX_ HV *hv)
	5825	__attribute__nonnull__(pTHX_1);
	5826	#define PERL_ARGS_ASSERT_HFREEENTRIES \
	5827	assert(hv)
	5828
	5829	STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize)
	5830	__attribute__nonnull__(pTHX_1);
	5831	#define PERL_ARGS_ASSERT_HSPLIT \
	5832	assert(hv)
	5833
	5834	STATIC struct xpvhv_aux* S_hv_auxinit(pTHX_ HV *hv)
	5835	__attribute__nonnull__(pTHX_1);
	5836	#define PERL_ARGS_ASSERT_HV_AUXINIT \
	5837	assert(hv)
	5838
	5839	STATIC SV* S_hv_delete_common(pTHX_ HV hv, SV keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash);
	5840	STATIC SV* S_hv_free_ent_ret(pTHX_ HV hv, HE entry)
	5841	__attribute__nonnull__(pTHX_1)
	5842	__attribute__nonnull__(pTHX_2);
	5843	#define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \
	5844	assert(hv); assert(entry)
	5845
	5846	STATIC void S_hv_magic_check(HV hv, bool needs_copy, bool *needs_store)
	5847	__attribute__nonnull__(1)
	5848	__attribute__nonnull__(2)
	5849	__attribute__nonnull__(3);
	5850	#define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \
	5851	assert(hv); assert(needs_copy); assert(needs_store)
	5852
	5853	PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char key, I32 klen, const char msg)
	5854	__attribute__noreturn__
	5855	__attribute__nonnull__(pTHX_2)
	5856	__attribute__nonnull__(pTHX_4);
	5857	#define PERL_ARGS_ASSERT_HV_NOTALLOWED \
	5858	assert(key); assert(msg)
	5859
	5860	STATIC HE* S_new_he(pTHX)
	5861	__attribute__malloc__
	5862	__attribute__warn_unused_result__;
	5863
	5864	PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u);
	5865	STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he)
	5866	__attribute__nonnull__(pTHX_1);
	5867	#define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \
	5868	assert(he)
	5869
	5870	STATIC HEK* S_save_hek_flags(const char *str, I32 len, U32 hash, int flags)
	5871	__attribute__malloc__
	5872	__attribute__warn_unused_result__
	5873	__attribute__nonnull__(1);
	5874	#define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \
	5875	assert(str)
	5876
	5877	STATIC HEK* S_share_hek_flags(pTHX_ const char *str, I32 len, U32 hash, int flags)
	5878	__attribute__warn_unused_result__
	5879	__attribute__nonnull__(pTHX_1);
	5880	#define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \
	5881	assert(str)
	5882
	5883	STATIC void S_unshare_hek_or_pvn(pTHX_ const HEK* hek, const char* str, I32 len, U32 hash);
	5884	#endif
	5885	#if defined(PERL_IN_HV_C) \|\| defined(PERL_IN_MG_C) \|\| defined(PERL_IN_SV_C)
	5886	PERL_CALLCONV void Perl_sv_kill_backrefs(pTHX_ SV const sv, AV const av)
	5887	__attribute__nonnull__(pTHX_1);
	5888	#define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \
	5889	assert(sv)
	5890
	5891	#endif
	5892	#if defined(PERL_IN_HV_C) \|\| defined(PERL_IN_SV_C)
	5893	PERL_CALLCONV SV* Perl_hfree_next_entry(pTHX_ HV hv, STRLEN indexp)
	5894	__attribute__nonnull__(pTHX_1)
	5895	__attribute__nonnull__(pTHX_2);
	5896	#define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY \
	5897	assert(hv); assert(indexp)
	5898
	5899	#endif
	5900	#if defined(PERL_IN_LOCALE_C) && defined(USE_LOCALE)
	5901	STATIC bool S_is_cur_LC_category_utf8(pTHX_ int category);
	5902	STATIC char* S_stdize_locale(pTHX_ char* locs)
	5903	__attribute__nonnull__(pTHX_1);
	5904	#define PERL_ARGS_ASSERT_STDIZE_LOCALE \
	5905	assert(locs)
	5906
	5907	#endif
	5908	#if defined(PERL_IN_MALLOC_C)
	5909	STATIC int S_adjust_size_and_find_bucket(size_t *nbytes_p)
	5910	__attribute__nonnull__(1);
	5911	#define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \
	5912	assert(nbytes_p)
	5913
	5914	#endif
	5915	#if defined(PERL_IN_MG_C)
	5916	STATIC void S_fixup_errno_string(pTHX_ SV* sv)
	5917	__attribute__nonnull__(pTHX_1);
	5918	#define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \
	5919	assert(sv)
	5920
	5921	STATIC SV* S_magic_methcall1(pTHX_ SV sv, const MAGIC mg, SV meth, U32 flags, int n, SV val)
	5922	__attribute__nonnull__(pTHX_1)
	5923	__attribute__nonnull__(pTHX_2)
	5924	__attribute__nonnull__(pTHX_3);
	5925	#define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \
	5926	assert(sv); assert(mg); assert(meth)
	5927
	5928	STATIC int S_magic_methpack(pTHX_ SV sv, const MAGIC mg, SV *meth)
	5929	__attribute__nonnull__(pTHX_1)
	5930	__attribute__nonnull__(pTHX_2)
	5931	__attribute__nonnull__(pTHX_3);
	5932	#define PERL_ARGS_ASSERT_MAGIC_METHPACK \
	5933	assert(sv); assert(mg); assert(meth)
	5934
	5935	STATIC void S_restore_magic(pTHX_ const void *p);
	5936	STATIC void S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags)
	5937	__attribute__nonnull__(pTHX_2);
	5938	#define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \
	5939	assert(sv)
	5940
	5941	STATIC void S_unwind_handler_stack(pTHX_ const void *p);
	5942	#endif
	5943	#if defined(PERL_IN_MG_C) \|\| defined(PERL_IN_PP_C)
	5944	PERL_CALLCONV bool Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN posp, STRLEN lenp)
	5945	__attribute__nonnull__(pTHX_6)
	5946	__attribute__nonnull__(pTHX_7);
	5947	#define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \
	5948	assert(posp); assert(lenp)
	5949
	5950	#endif
	5951	#if defined(PERL_IN_MRO_C)
	5952	STATIC void S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags)
	5953	__attribute__nonnull__(pTHX_1)
	5954	__attribute__nonnull__(pTHX_2);
	5955	#define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \
	5956	assert(isa); assert(name)
	5957
	5958	STATIC void S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV stash, HV oldstash, SV *namesv)
	5959	__attribute__nonnull__(pTHX_1)
	5960	__attribute__nonnull__(pTHX_2)
	5961	__attribute__nonnull__(pTHX_5);
	5962	#define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \
	5963	assert(stashes); assert(seen_stashes); assert(namesv)
	5964
	5965	STATIC AV* S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level)
	5966	__attribute__nonnull__(pTHX_1);
	5967	#define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \
	5968	assert(stash)
	5969
	5970	#endif
	5971	#if defined(PERL_IN_NUMERIC_C)
	5972	STATIC NV S_mulexp10(NV value, I32 exponent);
	5973	#endif
	5974	#if defined(PERL_IN_OP_C)
	5975	PERL_STATIC_INLINE bool S_aassign_common_vars(pTHX_ OP* o);
	5976	STATIC void S_apply_attrs(pTHX_ HV stash, SV target, OP *attrs)
	5977	__attribute__nonnull__(pTHX_1)
	5978	__attribute__nonnull__(pTHX_2);
	5979	#define PERL_ARGS_ASSERT_APPLY_ATTRS \
	5980	assert(stash); assert(target)
	5981
	5982	STATIC void S_apply_attrs_my(pTHX_ HV stash, OP target, OP attrs, OP *imopsp)
	5983	__attribute__nonnull__(pTHX_1)
	5984	__attribute__nonnull__(pTHX_2)
	5985	__attribute__nonnull__(pTHX_4);
	5986	#define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \
	5987	assert(stash); assert(target); assert(imopsp)
	5988
	5989	STATIC void S_bad_type_gv(pTHX_ I32 n, const char t, GV gv, U32 flags, const OP *kid)
	5990	__attribute__nonnull__(pTHX_2)
	5991	__attribute__nonnull__(pTHX_3)
	5992	__attribute__nonnull__(pTHX_5);
	5993	#define PERL_ARGS_ASSERT_BAD_TYPE_GV \
	5994	assert(t); assert(gv); assert(kid)
	5995
	5996	STATIC void S_bad_type_pv(pTHX_ I32 n, const char t, const char name, U32 flags, const OP *kid)
	5997	__attribute__nonnull__(pTHX_2)
	5998	__attribute__nonnull__(pTHX_3)
	5999	__attribute__nonnull__(pTHX_5);
	6000	#define PERL_ARGS_ASSERT_BAD_TYPE_PV \
	6001	assert(t); assert(name); assert(kid)
	6002
	6003	STATIC void S_cop_free(pTHX_ COP *cop)
	6004	__attribute__nonnull__(pTHX_1);
	6005	#define PERL_ARGS_ASSERT_COP_FREE \
	6006	assert(cop)
	6007
	6008	STATIC OP * S_dup_attrlist(pTHX_ OP *o)
	6009	__attribute__nonnull__(pTHX_1);
	6010	#define PERL_ARGS_ASSERT_DUP_ATTRLIST \
	6011	assert(o)
	6012
	6013	STATIC void S_finalize_op(pTHX_ OP* o)
	6014	__attribute__nonnull__(pTHX_1);
	6015	#define PERL_ARGS_ASSERT_FINALIZE_OP \
	6016	assert(o)
	6017
	6018	STATIC void S_find_and_forget_pmops(pTHX_ OP *o)
	6019	__attribute__nonnull__(pTHX_1);
	6020	#define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \
	6021	assert(o)
	6022
	6023	STATIC OP* S_fold_constants(pTHX_ OP *o)
	6024	__attribute__nonnull__(pTHX_1);
	6025	#define PERL_ARGS_ASSERT_FOLD_CONSTANTS \
	6026	assert(o)
	6027
	6028	STATIC OP* S_force_list(pTHX_ OP* arg);
	6029	STATIC void S_forget_pmop(pTHX_ PMOP *const o)
	6030	__attribute__nonnull__(pTHX_1);
	6031	#define PERL_ARGS_ASSERT_FORGET_PMOP \
	6032	assert(o)
	6033
	6034	STATIC OP* S_gen_constant_list(pTHX_ OP* o);
	6035	STATIC SV* S_gv_ename(pTHX_ GV *gv)
	6036	__attribute__nonnull__(pTHX_1);
	6037	#define PERL_ARGS_ASSERT_GV_ENAME \
	6038	assert(gv)
	6039
	6040	STATIC void S_inplace_aassign(pTHX_ OP* o)
	6041	__attribute__nonnull__(pTHX_1);
	6042	#define PERL_ARGS_ASSERT_INPLACE_AASSIGN \
	6043	assert(o)
	6044
	6045	STATIC bool S_is_handle_constructor(const OP *o, I32 numargs)
	6046	__attribute__warn_unused_result__
	6047	__attribute__nonnull__(1);
	6048	#define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \
	6049	assert(o)
	6050
	6051	STATIC I32 S_is_list_assignment(pTHX_ const OP *o)
	6052	__attribute__warn_unused_result__;
	6053
	6054	STATIC OP* S_listkids(pTHX_ OP* o);
	6055	STATIC bool S_looks_like_bool(pTHX_ const OP* o)
	6056	__attribute__nonnull__(pTHX_1);
	6057	#define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \
	6058	assert(o)
	6059
	6060	STATIC OP* S_modkids(pTHX_ OP *o, I32 type);
	6061	STATIC void S_move_proto_attr(pTHX_ OP proto, OP attrs, const GV *name)
	6062	__attribute__nonnull__(pTHX_1)
	6063	__attribute__nonnull__(pTHX_2)
	6064	__attribute__nonnull__(pTHX_3);
	6065	#define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \
	6066	assert(proto); assert(attrs); assert(name)
	6067
	6068	STATIC OP * S_my_kid(pTHX_ OP o, OP attrs, OP **imopsp)
	6069	__attribute__nonnull__(pTHX_3);
	6070	#define PERL_ARGS_ASSERT_MY_KID \
	6071	assert(imopsp)
	6072
	6073	STATIC OP* S_newDEFSVOP(pTHX)
	6074	__attribute__warn_unused_result__;
	6075
	6076	STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg)
	6077	__attribute__nonnull__(pTHX_2);
	6078	#define PERL_ARGS_ASSERT_NEWGIVWHENOP \
	6079	assert(block)
	6080
	6081	STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP firstp, OP otherp)
	6082	__attribute__warn_unused_result__
	6083	__attribute__nonnull__(pTHX_3)
	6084	__attribute__nonnull__(pTHX_4);
	6085	#define PERL_ARGS_ASSERT_NEW_LOGOP \
	6086	assert(firstp); assert(otherp)
	6087
	6088	STATIC void S_no_bareword_allowed(pTHX_ OP *o)
	6089	__attribute__nonnull__(pTHX_1);
	6090	#define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \
	6091	assert(o)
	6092
	6093	STATIC OP* S_no_fh_allowed(pTHX_ OP *o)
	6094	__attribute__warn_unused_result__
	6095	__attribute__nonnull__(pTHX_1);
	6096	#define PERL_ARGS_ASSERT_NO_FH_ALLOWED \
	6097	assert(o)
	6098
	6099	PERL_STATIC_INLINE OP* S_op_integerize(pTHX_ OP *o)
	6100	__attribute__nonnull__(pTHX_1);
	6101	#define PERL_ARGS_ASSERT_OP_INTEGERIZE \
	6102	assert(o)
	6103
	6104	PERL_STATIC_INLINE OP* S_op_std_init(pTHX_ OP *o)
	6105	__attribute__nonnull__(pTHX_1);
	6106	#define PERL_ARGS_ASSERT_OP_STD_INIT \
	6107	assert(o)
	6108
	6109	STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl)
	6110	__attribute__nonnull__(pTHX_1)
	6111	__attribute__nonnull__(pTHX_2)
	6112	__attribute__nonnull__(pTHX_3);
	6113	#define PERL_ARGS_ASSERT_PMTRANS \
	6114	assert(o); assert(expr); assert(repl)
	6115
	6116	STATIC void S_process_special_blocks(pTHX_ I32 floor, const char const fullname, GV const gv, CV *const cv)
	6117	__attribute__nonnull__(pTHX_2)
	6118	__attribute__nonnull__(pTHX_3)
	6119	__attribute__nonnull__(pTHX_4);
	6120	#define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \
	6121	assert(fullname); assert(gv); assert(cv)
	6122
	6123	STATIC OP* S_ref_array_or_hash(pTHX_ OP* cond);
	6124	STATIC OP* S_refkids(pTHX_ OP* o, I32 type);
	6125	STATIC bool S_scalar_mod_type(const OP *o, I32 type)
	6126	__attribute__warn_unused_result__;
	6127
	6128	STATIC OP* S_scalarboolean(pTHX_ OP *o)
	6129	__attribute__nonnull__(pTHX_1);
	6130	#define PERL_ARGS_ASSERT_SCALARBOOLEAN \
	6131	assert(o)
	6132
	6133	STATIC OP* S_scalarkids(pTHX_ OP* o);
	6134	STATIC OP* S_scalarseq(pTHX_ OP* o);
	6135	STATIC OP* S_search_const(pTHX_ OP *o)
	6136	__attribute__warn_unused_result__
	6137	__attribute__nonnull__(pTHX_1);
	6138	#define PERL_ARGS_ASSERT_SEARCH_CONST \
	6139	assert(o)
	6140
	6141	STATIC void S_simplify_sort(pTHX_ OP *o)
	6142	__attribute__nonnull__(pTHX_1);
	6143	#define PERL_ARGS_ASSERT_SIMPLIFY_SORT \
	6144	assert(o)
	6145
	6146	STATIC OP* S_too_few_arguments_pv(pTHX_ OP o, const char name, U32 flags)
	6147	__attribute__warn_unused_result__
	6148	__attribute__nonnull__(pTHX_1)
	6149	__attribute__nonnull__(pTHX_2);
	6150	#define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \
	6151	assert(o); assert(name)
	6152
	6153	STATIC OP* S_too_few_arguments_sv(pTHX_ OP o, SV namesv, U32 flags)
	6154	__attribute__warn_unused_result__
	6155	__attribute__nonnull__(pTHX_1)
	6156	__attribute__nonnull__(pTHX_2);
	6157	#define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_SV \
	6158	assert(o); assert(namesv)
	6159
	6160	STATIC OP* S_too_many_arguments_pv(pTHX_ OP o, const char name, U32 flags)
	6161	__attribute__nonnull__(pTHX_1)
	6162	__attribute__nonnull__(pTHX_2);
	6163	#define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \
	6164	assert(o); assert(name)
	6165
	6166	STATIC OP* S_too_many_arguments_sv(pTHX_ OP o, SV namesv, U32 flags)
	6167	__attribute__warn_unused_result__
	6168	__attribute__nonnull__(pTHX_1)
	6169	__attribute__nonnull__(pTHX_2);
	6170	#define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \
	6171	assert(o); assert(namesv)
	6172
	6173	#endif
	6174	#if defined(PERL_IN_OP_C) \|\| defined(PERL_IN_SV_C)
	6175	PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV name, const CV old_cv, SV * const *new_const_svp)
	6176	__attribute__nonnull__(pTHX_1)
	6177	__attribute__nonnull__(pTHX_2);
	6178	#define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV \
	6179	assert(name); assert(old_cv)
	6180
	6181	#endif
	6182	#if defined(PERL_IN_PAD_C)
	6183	STATIC PADOFFSET S_pad_alloc_name(pTHX_ SV namesv, U32 flags, HV typestash, HV *ourstash)
	6184	__attribute__nonnull__(pTHX_1);
	6185	#define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \
	6186	assert(namesv)
	6187
	6188	STATIC void S_pad_check_dup(pTHX_ SV name, U32 flags, const HV ourstash)
	6189	__attribute__nonnull__(pTHX_1);
	6190	#define PERL_ARGS_ASSERT_PAD_CHECK_DUP \
	6191	assert(name)
	6192
	6193	STATIC PADOFFSET S_pad_findlex(pTHX_ const char namepv, STRLEN namelen, U32 flags, const CV cv, U32 seq, int warn, SV out_capture, SV out_name_sv, int *out_flags)
	6194	__attribute__nonnull__(pTHX_1)
	6195	__attribute__nonnull__(pTHX_4)
	6196	__attribute__nonnull__(pTHX_8)
	6197	__attribute__nonnull__(pTHX_9);
	6198	#define PERL_ARGS_ASSERT_PAD_FINDLEX \
	6199	assert(namepv); assert(cv); assert(out_name_sv); assert(out_flags)
	6200
	6201	STATIC void S_pad_reset(pTHX);
	6202	#endif
	6203	#if defined(PERL_IN_PERL_C)
	6204	STATIC void S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp)
	6205	__attribute__nonnull__(pTHX_1)
	6206	__attribute__nonnull__(pTHX_2);
	6207	#define PERL_ARGS_ASSERT_FIND_BEGINNING \
	6208	assert(linestr_sv); assert(rsfp)
	6209
	6210	STATIC void S_forbid_setid(pTHX_ const char flag, const bool suidscript);
	6211	STATIC void S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags)
	6212	__attribute__nonnull__(pTHX_1);
	6213	#define PERL_ARGS_ASSERT_INCPUSH \
	6214	assert(dir)
	6215
	6216	STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags)
	6217	__attribute__nonnull__(pTHX_1);
	6218	#define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \
	6219	assert(p)
	6220
	6221	STATIC void S_init_ids(pTHX);
	6222	STATIC void S_init_interp(pTHX);
	6223	STATIC void S_init_main_stash(pTHX);
	6224	STATIC void S_init_perllib(pTHX);
	6225	STATIC void S_init_postdump_symbols(pTHX_ int argc, char argv, char env)
	6226	__attribute__nonnull__(pTHX_2);
	6227	#define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \
	6228	assert(argv)
	6229
	6230	STATIC void S_init_predump_symbols(pTHX);
	6231	STATIC SV* S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags)
	6232	__attribute__nonnull__(pTHX_1);
	6233	#define PERL_ARGS_ASSERT_MAYBERELOCATE \
	6234	assert(dir)
	6235
	6236	PERL_STATIC_NO_RET void S_minus_v(pTHX)
	6237	__attribute__noreturn__;
	6238
	6239	PERL_STATIC_NO_RET void S_my_exit_jump(pTHX)
	6240	__attribute__noreturn__;
	6241
	6242	STATIC void S_nuke_stacks(pTHX);
	6243	STATIC PerlIO * S_open_script(pTHX_ const char scriptname, bool dosearch, bool suidscript)
	6244	__attribute__nonnull__(pTHX_1)
	6245	__attribute__nonnull__(pTHX_3);
	6246	#define PERL_ARGS_ASSERT_OPEN_SCRIPT \
	6247	assert(scriptname); assert(suidscript)
	6248
	6249	STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit);
	6250	PERL_STATIC_NO_RET void S_run_body(pTHX_ I32 oldscope)
	6251	__attribute__noreturn__;
	6252
	6253	PERL_STATIC_NO_RET void S_usage(pTHX)
	6254	__attribute__noreturn__;
	6255
	6256	#endif
	6257	#if defined(PERL_IN_PP_C)
	6258	STATIC void S_do_chomp(pTHX_ SV retval, SV sv, bool chomping)
	6259	__attribute__nonnull__(pTHX_1)
	6260	__attribute__nonnull__(pTHX_2);
	6261	#define PERL_ARGS_ASSERT_DO_CHOMP \
	6262	assert(retval); assert(sv)
	6263
	6264	STATIC OP* S_do_delete_local(pTHX);
	6265	STATIC SV* S_refto(pTHX_ SV* sv)
	6266	__attribute__warn_unused_result__
	6267	__attribute__nonnull__(pTHX_1);
	6268	#define PERL_ARGS_ASSERT_REFTO \
	6269	assert(sv)
	6270
	6271	#endif
	6272	#if defined(PERL_IN_PP_C) \|\| defined(PERL_IN_PP_HOT_C)
	6273	PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV const sv, const char const what, const svtype type, SV ***spp)
	6274	__attribute__warn_unused_result__
	6275	__attribute__nonnull__(pTHX_1)
	6276	__attribute__nonnull__(pTHX_2)
	6277	__attribute__nonnull__(pTHX_4);
	6278	#define PERL_ARGS_ASSERT_SOFTREF2XV \
	6279	assert(sv); assert(what); assert(spp)
	6280
	6281	#endif
	6282	#if defined(PERL_IN_PP_CTL_C)
	6283	STATIC SV S_adjust_stack_on_leave(pTHX_ SV newsp, SV sp, SV mark, I32 gimme, U32 flags, bool lvalue)
	6284	__attribute__nonnull__(pTHX_1)
	6285	__attribute__nonnull__(pTHX_2)
	6286	__attribute__nonnull__(pTHX_3);
	6287	#define PERL_ARGS_ASSERT_ADJUST_STACK_ON_LEAVE \
	6288	assert(newsp); assert(sp); assert(mark)
	6289
	6290	STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name)
	6291	__attribute__warn_unused_result__
	6292	__attribute__nonnull__(pTHX_1);
	6293	#define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \
	6294	assert(name)
	6295
	6296	STATIC void S_destroy_matcher(pTHX_ PMOP* matcher)
	6297	__attribute__nonnull__(pTHX_1);
	6298	#define PERL_ARGS_ASSERT_DESTROY_MATCHER \
	6299	assert(matcher)
	6300
	6301	STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied);
	6302	STATIC OP* S_docatch(pTHX_ OP *o)
	6303	__attribute__warn_unused_result__;
	6304
	6305	STATIC bool S_doeval(pTHX_ int gimme, CV* outside, U32 seq, HV* hh);
	6306	STATIC OP* S_dofindlabel(pTHX_ OP o, const char label, STRLEN len, U32 flags, OP opstack, OP oplimit)
	6307	__attribute__warn_unused_result__
	6308	__attribute__nonnull__(pTHX_1)
	6309	__attribute__nonnull__(pTHX_2)
	6310	__attribute__nonnull__(pTHX_5)
	6311	__attribute__nonnull__(pTHX_6);
	6312	#define PERL_ARGS_ASSERT_DOFINDLABEL \
	6313	assert(o); assert(label); assert(opstack); assert(oplimit)
	6314
	6315	STATIC MAGIC * S_doparseform(pTHX_ SV *sv)
	6316	__attribute__nonnull__(pTHX_1);
	6317	#define PERL_ARGS_ASSERT_DOPARSEFORM \
	6318	assert(sv)
	6319
	6320	STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock)
	6321	__attribute__warn_unused_result__;
	6322
	6323	STATIC I32 S_dopoptogiven(pTHX_ I32 startingblock)
	6324	__attribute__warn_unused_result__;
	6325
	6326	STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags)
	6327	__attribute__warn_unused_result__
	6328	__attribute__nonnull__(pTHX_1);
	6329	#define PERL_ARGS_ASSERT_DOPOPTOLABEL \
	6330	assert(label)
	6331
	6332	STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock)
	6333	__attribute__warn_unused_result__;
	6334
	6335	STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock)
	6336	__attribute__warn_unused_result__
	6337	__attribute__nonnull__(pTHX_1);
	6338	#define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \
	6339	assert(cxstk)
	6340
	6341	STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock)
	6342	__attribute__warn_unused_result__;
	6343
	6344	STATIC PMOP* S_make_matcher(pTHX_ REGEXP* re)
	6345	__attribute__warn_unused_result__
	6346	__attribute__nonnull__(pTHX_1);
	6347	#define PERL_ARGS_ASSERT_MAKE_MATCHER \
	6348	assert(re)
	6349
	6350	STATIC bool S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv)
	6351	__attribute__warn_unused_result__
	6352	__attribute__nonnull__(pTHX_1)
	6353	__attribute__nonnull__(pTHX_2);
	6354	#define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \
	6355	assert(matcher); assert(sv)
	6356
	6357	STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize)
	6358	__attribute__warn_unused_result__;
	6359
	6360	PERL_STATIC_INLINE bool S_path_is_searchable(const char *name)
	6361	__attribute__warn_unused_result__
	6362	__attribute__nonnull__(1);
	6363	#define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \
	6364	assert(name)
	6365
	6366	STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen)
	6367	__attribute__warn_unused_result__
	6368	__attribute__nonnull__(pTHX_2);
	6369	#define PERL_ARGS_ASSERT_RUN_USER_FILTER \
	6370	assert(buf_sv)
	6371
	6372	STATIC void S_rxres_free(pTHX_ void** rsp)
	6373	__attribute__nonnull__(pTHX_1);
	6374	#define PERL_ARGS_ASSERT_RXRES_FREE \
	6375	assert(rsp)
	6376
	6377	STATIC void S_rxres_restore(pTHX_ void *rsp, REGEXP rx)
	6378	__attribute__nonnull__(pTHX_1)
	6379	__attribute__nonnull__(pTHX_2);
	6380	#define PERL_ARGS_ASSERT_RXRES_RESTORE \
	6381	assert(rsp); assert(rx)
	6382
	6383	STATIC void S_save_lines(pTHX_ AV array, SV sv)
	6384	__attribute__nonnull__(pTHX_2);
	6385	#define PERL_ARGS_ASSERT_SAVE_LINES \
	6386	assert(sv)
	6387
	6388	#endif
	6389	#if defined(PERL_IN_PP_HOT_C)
	6390	STATIC void S_do_oddball(pTHX_ SV oddkey, SV firstkey)
	6391	__attribute__nonnull__(pTHX_1)
	6392	__attribute__nonnull__(pTHX_2);
	6393	#define PERL_ARGS_ASSERT_DO_ODDBALL \
	6394	assert(oddkey); assert(firstkey)
	6395
	6396	STATIC SV* S_method_common(pTHX_ SV* meth, U32* hashp)
	6397	__attribute__warn_unused_result__
	6398	__attribute__nonnull__(pTHX_1);
	6399	#define PERL_ARGS_ASSERT_METHOD_COMMON \
	6400	assert(meth)
	6401
	6402	#endif
	6403	#if defined(PERL_IN_PP_PACK_C)
	6404	STATIC char * S_bytes_to_uni(const U8 start, STRLEN len, char dest, const bool needs_swap)
	6405	__attribute__warn_unused_result__
	6406	__attribute__nonnull__(1)
	6407	__attribute__nonnull__(3);
	6408	#define PERL_ARGS_ASSERT_BYTES_TO_UNI \
	6409	assert(start); assert(dest)
	6410
	6411	STATIC int S_div128(pTHX_ SV pnum, bool done)
	6412	__attribute__nonnull__(pTHX_1)
	6413	__attribute__nonnull__(pTHX_2);
	6414	#define PERL_ARGS_ASSERT_DIV128 \
	6415	assert(pnum); assert(done)
	6416
	6417	STATIC char S_first_symbol(const char pat, const char patend)
	6418	__attribute__nonnull__(1)
	6419	__attribute__nonnull__(2);
	6420	#define PERL_ARGS_ASSERT_FIRST_SYMBOL \
	6421	assert(pat); assert(patend)
	6422
	6423	STATIC const char * S_get_num(pTHX_ const char patptr, I32 lenptr)
	6424	__attribute__warn_unused_result__
	6425	__attribute__nonnull__(pTHX_1)
	6426	__attribute__nonnull__(pTHX_2);
	6427	#define PERL_ARGS_ASSERT_GET_NUM \
	6428	assert(patptr); assert(lenptr)
	6429
	6430	STATIC const char * S_group_end(pTHX_ const char patptr, const char patend, char ender)
	6431	__attribute__nonnull__(pTHX_1)
	6432	__attribute__nonnull__(pTHX_2);
	6433	#define PERL_ARGS_ASSERT_GROUP_END \
	6434	assert(patptr); assert(patend)
	6435
	6436	STATIC SV* S_is_an_int(pTHX_ const char *s, STRLEN l)
	6437	__attribute__warn_unused_result__
	6438	__attribute__nonnull__(pTHX_1);
	6439	#define PERL_ARGS_ASSERT_IS_AN_INT \
	6440	assert(s)
	6441
	6442	STATIC I32 S_measure_struct(pTHX_ struct tempsym* symptr)
	6443	__attribute__nonnull__(pTHX_1);
	6444	#define PERL_ARGS_ASSERT_MEASURE_STRUCT \
	6445	assert(symptr)
	6446
	6447	STATIC SV* S_mul128(pTHX_ SV *sv, U8 m)
	6448	__attribute__nonnull__(pTHX_1);
	6449	#define PERL_ARGS_ASSERT_MUL128 \
	6450	assert(sv)
	6451
	6452	STATIC bool S_need_utf8(const char pat, const char patend)
	6453	__attribute__nonnull__(1)
	6454	__attribute__nonnull__(2);
	6455	#define PERL_ARGS_ASSERT_NEED_UTF8 \
	6456	assert(pat); assert(patend)
	6457
	6458	STATIC bool S_next_symbol(pTHX_ struct tempsym* symptr)
	6459	__attribute__nonnull__(pTHX_1);
	6460	#define PERL_ARGS_ASSERT_NEXT_SYMBOL \
	6461	assert(symptr)
	6462
	6463	STATIC SV ** S_pack_rec(pTHX_ SV cat, struct tempsym symptr, SV beglist, SV endlist)
	6464	__attribute__nonnull__(pTHX_1)
	6465	__attribute__nonnull__(pTHX_2)
	6466	__attribute__nonnull__(pTHX_3)
	6467	__attribute__nonnull__(pTHX_4);
	6468	#define PERL_ARGS_ASSERT_PACK_REC \
	6469	assert(cat); assert(symptr); assert(beglist); assert(endlist)
	6470
	6471	STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed)
	6472	__attribute__warn_unused_result__
	6473	__attribute__nonnull__(pTHX_1);
	6474	#define PERL_ARGS_ASSERT_SV_EXP_GROW \
	6475	assert(sv)
	6476
	6477	STATIC I32 S_unpack_rec(pTHX_ struct tempsym* symptr, const char s, const char strbeg, const char strend, const char *new_s)
	6478	__attribute__nonnull__(pTHX_1)
	6479	__attribute__nonnull__(pTHX_2)
	6480	__attribute__nonnull__(pTHX_3)
	6481	__attribute__nonnull__(pTHX_4);
	6482	#define PERL_ARGS_ASSERT_UNPACK_REC \
	6483	assert(symptr); assert(s); assert(strbeg); assert(strend)
	6484
	6485	#endif
	6486	#if defined(PERL_IN_PP_SORT_C)
	6487	STATIC I32 S_amagic_cmp(pTHX_ SV const str1, SV const str2)
	6488	__attribute__nonnull__(pTHX_1)
	6489	__attribute__nonnull__(pTHX_2);
	6490	#define PERL_ARGS_ASSERT_AMAGIC_CMP \
	6491	assert(str1); assert(str2)
	6492
	6493	STATIC I32 S_amagic_cmp_locale(pTHX_ SV const str1, SV const str2)
	6494	__attribute__nonnull__(pTHX_1)
	6495	__attribute__nonnull__(pTHX_2);
	6496	#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \
	6497	assert(str1); assert(str2)
	6498
	6499	STATIC I32 S_amagic_i_ncmp(pTHX_ SV const a, SV const b)
	6500	__attribute__nonnull__(pTHX_1)
	6501	__attribute__nonnull__(pTHX_2);
	6502	#define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \
	6503	assert(a); assert(b)
	6504
	6505	STATIC I32 S_amagic_ncmp(pTHX_ SV const a, SV const b)
	6506	__attribute__nonnull__(pTHX_1)
	6507	__attribute__nonnull__(pTHX_2);
	6508	#define PERL_ARGS_ASSERT_AMAGIC_NCMP \
	6509	assert(a); assert(b)
	6510
	6511	STATIC void S_qsortsvu(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t compare)
	6512	__attribute__nonnull__(pTHX_3);
	6513	#define PERL_ARGS_ASSERT_QSORTSVU \
	6514	assert(compare)
	6515
	6516	STATIC I32 S_sortcv(pTHX_ SV const a, SV const b)
	6517	__attribute__nonnull__(pTHX_1)
	6518	__attribute__nonnull__(pTHX_2);
	6519	#define PERL_ARGS_ASSERT_SORTCV \
	6520	assert(a); assert(b)
	6521
	6522	STATIC I32 S_sortcv_stacked(pTHX_ SV const a, SV const b)
	6523	__attribute__nonnull__(pTHX_1)
	6524	__attribute__nonnull__(pTHX_2);
	6525	#define PERL_ARGS_ASSERT_SORTCV_STACKED \
	6526	assert(a); assert(b)
	6527
	6528	STATIC I32 S_sortcv_xsub(pTHX_ SV const a, SV const b)
	6529	__attribute__nonnull__(pTHX_1)
	6530	__attribute__nonnull__(pTHX_2);
	6531	#define PERL_ARGS_ASSERT_SORTCV_XSUB \
	6532	assert(a); assert(b)
	6533
	6534	STATIC I32 S_sv_i_ncmp(pTHX_ SV const a, SV const b)
	6535	__attribute__nonnull__(pTHX_1)
	6536	__attribute__nonnull__(pTHX_2);
	6537	#define PERL_ARGS_ASSERT_SV_I_NCMP \
	6538	assert(a); assert(b)
	6539
	6540	STATIC I32 S_sv_ncmp(pTHX_ SV const a, SV const b)
	6541	__attribute__nonnull__(pTHX_1)
	6542	__attribute__nonnull__(pTHX_2);
	6543	#define PERL_ARGS_ASSERT_SV_NCMP \
	6544	assert(a); assert(b)
	6545
	6546	#endif
	6547	#if defined(PERL_IN_PP_SYS_C)
	6548	STATIC OP* S_doform(pTHX_ CV cv, GV gv, OP *retop)
	6549	__attribute__nonnull__(pTHX_1)
	6550	__attribute__nonnull__(pTHX_2)
	6551	__attribute__nonnull__(pTHX_3);
	6552	#define PERL_ARGS_ASSERT_DOFORM \
	6553	assert(cv); assert(gv); assert(retop)
	6554
	6555	STATIC SV * S_space_join_names_mortal(pTHX_ char const array)
	6556	__attribute__nonnull__(pTHX_1);
	6557	#define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL \
	6558	assert(array)
	6559
	6560	#endif
	6561	#if defined(PERL_IN_REGCOMP_C)
	6562	STATIC void S__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, const UV end)
	6563	__attribute__nonnull__(pTHX_1);
	6564	#define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \
	6565	assert(invlist)
	6566
	6567	PERL_STATIC_INLINE UV* S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0)
	6568	__attribute__warn_unused_result__
	6569	__attribute__nonnull__(pTHX_1);
	6570	#define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \
	6571	assert(invlist)
	6572
	6573	PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
	6574	__attribute__warn_unused_result__;
	6575
	6576	STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n)
	6577	__attribute__warn_unused_result__
	6578	__attribute__nonnull__(1)
	6579	__attribute__nonnull__(2);
	6580	#define PERL_ARGS_ASSERT_ADD_DATA \
	6581	assert(pRExC_state); assert(s)
	6582
	6583	PERL_STATIC_INLINE void S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t pRExC_state, regnode node, I32 *flagp, STRLEN len, UV code_point)
	6584	__attribute__nonnull__(pTHX_1)
	6585	__attribute__nonnull__(pTHX_2)
	6586	__attribute__nonnull__(pTHX_3);
	6587	#define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT \
	6588	assert(pRExC_state); assert(node); assert(flagp)
	6589
	6590	PERL_STATIC_INLINE U8 S_compute_EXACTish(pTHX_ RExC_state_t *pRExC_state)
	6591	__attribute__nonnull__(pTHX_1);
	6592	#define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \
	6593	assert(pRExC_state)
	6594
	6595	STATIC bool S_could_it_be_a_POSIX_class(pTHX_ RExC_state_t *pRExC_state)
	6596	__attribute__nonnull__(pTHX_1);
	6597	#define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS \
	6598	assert(pRExC_state)
	6599
	6600	STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t pRExC_state, const regnode_charclass_posixl const node)
	6601	__attribute__nonnull__(pTHX_1)
	6602	__attribute__nonnull__(pTHX_2);
	6603	#define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \
	6604	assert(pRExC_state); assert(node)
	6605
	6606	PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(pTHX_ SV* invlist)
	6607	__attribute__warn_unused_result__
	6608	__attribute__nonnull__(pTHX_1);
	6609	#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
	6610	assert(invlist)
	6611
	6612	PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(pTHX_ SV* invlist)
	6613	__attribute__warn_unused_result__
	6614	__attribute__nonnull__(pTHX_1);
	6615	#define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \
	6616	assert(invlist)
	6617
	6618	STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t pRExC_state, regnode* nodep, UV valuep, I32 flagp, U32 depth, bool in_char_class, const bool strict)
	6619	__attribute__nonnull__(pTHX_1)
	6620	__attribute__nonnull__(pTHX_4);
	6621	#define PERL_ARGS_ASSERT_GROK_BSLASH_N \
	6622	assert(pRExC_state); assert(flagp)
	6623
	6624	STATIC regnode* S_handle_regex_sets(pTHX_ RExC_state_t pRExC_state, SV * return_invlist, I32 flagp, U32 depth, char const oregcomp_parse)
	6625	__attribute__nonnull__(pTHX_1)
	6626	__attribute__nonnull__(pTHX_3)
	6627	__attribute__nonnull__(pTHX_5);
	6628	#define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \
	6629	assert(pRExC_state); assert(flagp); assert(oregcomp_parse)
	6630
	6631	PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist)
	6632	__attribute__warn_unused_result__
	6633	__attribute__nonnull__(pTHX_1);
	6634	#define PERL_ARGS_ASSERT_INVLIST_ARRAY \
	6635	assert(invlist)
	6636
	6637	PERL_STATIC_INLINE SV* S_invlist_clone(pTHX_ SV* const invlist)
	6638	__attribute__warn_unused_result__
	6639	__attribute__nonnull__(pTHX_1);
	6640	#define PERL_ARGS_ASSERT_INVLIST_CLONE \
	6641	assert(invlist)
	6642
	6643	STATIC void S_invlist_extend(pTHX_ SV* const invlist, const UV len)
	6644	__attribute__nonnull__(pTHX_1);
	6645	#define PERL_ARGS_ASSERT_INVLIST_EXTEND \
	6646	assert(invlist)
	6647
	6648	PERL_STATIC_INLINE UV S_invlist_highest(pTHX_ SV* const invlist)
	6649	__attribute__warn_unused_result__
	6650	__attribute__nonnull__(pTHX_1);
	6651	#define PERL_ARGS_ASSERT_INVLIST_HIGHEST \
	6652	assert(invlist)
	6653
	6654	PERL_STATIC_INLINE bool S_invlist_is_iterating(pTHX_ SV* const invlist)
	6655	__attribute__warn_unused_result__
	6656	__attribute__nonnull__(pTHX_1);
	6657	#define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \
	6658	assert(invlist)
	6659
	6660	PERL_STATIC_INLINE void S_invlist_iterfinish(pTHX_ SV* invlist)
	6661	__attribute__nonnull__(pTHX_1);
	6662	#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \
	6663	assert(invlist)
	6664
	6665	PERL_STATIC_INLINE void S_invlist_iterinit(pTHX_ SV* invlist)
	6666	__attribute__nonnull__(pTHX_1);
	6667	#define PERL_ARGS_ASSERT_INVLIST_ITERINIT \
	6668	assert(invlist)
	6669
	6670	STATIC bool S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end)
	6671	__attribute__warn_unused_result__
	6672	__attribute__nonnull__(pTHX_1)
	6673	__attribute__nonnull__(pTHX_2)
	6674	__attribute__nonnull__(pTHX_3);
	6675	#define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \
	6676	assert(invlist); assert(start); assert(end)
	6677
	6678	PERL_STATIC_INLINE UV S_invlist_max(pTHX_ SV* const invlist)
	6679	__attribute__warn_unused_result__
	6680	__attribute__nonnull__(pTHX_1);
	6681	#define PERL_ARGS_ASSERT_INVLIST_MAX \
	6682	assert(invlist)
	6683
	6684	PERL_STATIC_INLINE IV S_invlist_previous_index(pTHX_ SV* const invlist)
	6685	__attribute__warn_unused_result__
	6686	__attribute__nonnull__(pTHX_1);
	6687	#define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \
	6688	assert(invlist)
	6689
	6690	PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
	6691	__attribute__nonnull__(pTHX_1);
	6692	#define PERL_ARGS_ASSERT_INVLIST_SET_LEN \
	6693	assert(invlist)
	6694
	6695	PERL_STATIC_INLINE void S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index)
	6696	__attribute__nonnull__(pTHX_1);
	6697	#define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \
	6698	assert(invlist)
	6699
	6700	PERL_STATIC_INLINE void S_invlist_trim(pTHX_ SV* const invlist)
	6701	__attribute__nonnull__(pTHX_1);
	6702	#define PERL_ARGS_ASSERT_INVLIST_TRIM \
	6703	assert(invlist)
	6704
	6705	STATIC U32 S_join_exact(pTHX_ RExC_state_t pRExC_state, regnode scan, UV min_subtract, bool has_exactf_sharp_s, U32 flags, regnode *val, U32 depth)
	6706	__attribute__nonnull__(pTHX_1)
	6707	__attribute__nonnull__(pTHX_2)
	6708	__attribute__nonnull__(pTHX_3)
	6709	__attribute__nonnull__(pTHX_4);
	6710	#define PERL_ARGS_ASSERT_JOIN_EXACT \
	6711	assert(pRExC_state); assert(scan); assert(min_subtract); assert(has_exactf_sharp_s)
	6712
	6713	STATIC I32 S_make_trie(pTHX_ RExC_state_t pRExC_state, regnode startbranch, regnode first, regnode last, regnode *tail, U32 word_count, U32 flags, U32 depth)
	6714	__attribute__nonnull__(pTHX_1)
	6715	__attribute__nonnull__(pTHX_2)
	6716	__attribute__nonnull__(pTHX_3)
	6717	__attribute__nonnull__(pTHX_4)
	6718	__attribute__nonnull__(pTHX_5);
	6719	#define PERL_ARGS_ASSERT_MAKE_TRIE \
	6720	assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail)
	6721
	6722	STATIC void S_make_trie_failtable(pTHX_ RExC_state_t pRExC_state, regnode source, regnode *stclass, U32 depth)
	6723	__attribute__nonnull__(pTHX_1)
	6724	__attribute__nonnull__(pTHX_2)
	6725	__attribute__nonnull__(pTHX_3);
	6726	#define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE \
	6727	assert(pRExC_state); assert(source); assert(stclass)
	6728
	6729	STATIC char * S_nextchar(pTHX_ RExC_state_t *pRExC_state)
	6730	__attribute__nonnull__(pTHX_1);
	6731	#define PERL_ARGS_ASSERT_NEXTCHAR \
	6732	assert(pRExC_state)
	6733
	6734	STATIC void S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state)
	6735	__attribute__nonnull__(pTHX_1);
	6736	#define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \
	6737	assert(pRExC_state)
	6738
	6739	STATIC void S_populate_ANYOF_from_invlist(pTHX_ regnode node, SV* invlist_ptr)
	6740	__attribute__nonnull__(pTHX_1)
	6741	__attribute__nonnull__(pTHX_2);
	6742	#define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST \
	6743	assert(node); assert(invlist_ptr)
	6744
	6745	PERL_STATIC_NO_RET void S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2, ...)
	6746	__attribute__noreturn__
	6747	__attribute__nonnull__(pTHX_2)
	6748	__attribute__nonnull__(pTHX_3);
	6749	#define PERL_ARGS_ASSERT_RE_CROAK2 \
	6750	assert(pat1); assert(pat2)
	6751
	6752	STATIC regnode* S_reg(pTHX_ RExC_state_t pRExC_state, I32 paren, I32 flagp, U32 depth)
	6753	__attribute__nonnull__(pTHX_1)
	6754	__attribute__nonnull__(pTHX_3);
	6755	#define PERL_ARGS_ASSERT_REG \
	6756	assert(pRExC_state); assert(flagp)
	6757
	6758	STATIC regnode* S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)
	6759	__attribute__nonnull__(pTHX_1);
	6760	#define PERL_ARGS_ASSERT_REG_NODE \
	6761	assert(pRExC_state)
	6762
	6763	STATIC UV S_reg_recode(pTHX_ const char value, SV **encp)
	6764	__attribute__nonnull__(pTHX_2);
	6765	#define PERL_ARGS_ASSERT_REG_RECODE \
	6766	assert(encp)
	6767
	6768	STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)
	6769	__attribute__nonnull__(pTHX_1);
	6770	#define PERL_ARGS_ASSERT_REG_SCAN_NAME \
	6771	assert(pRExC_state)
	6772
	6773	STATIC bool S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state)
	6774	__attribute__nonnull__(pTHX_1);
	6775	#define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \
	6776	assert(pRExC_state)
	6777
	6778	STATIC regnode* S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
	6779	__attribute__nonnull__(pTHX_1);
	6780	#define PERL_ARGS_ASSERT_REGANODE \
	6781	assert(pRExC_state)
	6782
	6783	STATIC regnode* S_regatom(pTHX_ RExC_state_t pRExC_state, I32 flagp, U32 depth)
	6784	__attribute__nonnull__(pTHX_1)
	6785	__attribute__nonnull__(pTHX_2);
	6786	#define PERL_ARGS_ASSERT_REGATOM \
	6787	assert(pRExC_state); assert(flagp)
	6788
	6789	STATIC regnode* S_regbranch(pTHX_ RExC_state_t pRExC_state, I32 flagp, I32 first, U32 depth)
	6790	__attribute__nonnull__(pTHX_1)
	6791	__attribute__nonnull__(pTHX_2);
	6792	#define PERL_ARGS_ASSERT_REGBRANCH \
	6793	assert(pRExC_state); assert(flagp)
	6794
	6795	STATIC regnode* S_regclass(pTHX_ RExC_state_t pRExC_state, I32 flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, SV** ret_invlist)
	6796	__attribute__nonnull__(pTHX_1)
	6797	__attribute__nonnull__(pTHX_2);
	6798	#define PERL_ARGS_ASSERT_REGCLASS \
	6799	assert(pRExC_state); assert(flagp)
	6800
	6801	STATIC void S_reginsert(pTHX_ RExC_state_t pRExC_state, U8 op, regnode opnd, U32 depth)
	6802	__attribute__nonnull__(pTHX_1)
	6803	__attribute__nonnull__(pTHX_3);
	6804	#define PERL_ARGS_ASSERT_REGINSERT \
	6805	assert(pRExC_state); assert(opnd)
	6806
	6807	STATIC char * S_regpatws(RExC_state_t pRExC_state, char p, const bool recognize_comment)
	6808	__attribute__warn_unused_result__
	6809	__attribute__nonnull__(1)
	6810	__attribute__nonnull__(2);
	6811	#define PERL_ARGS_ASSERT_REGPATWS \
	6812	assert(pRExC_state); assert(p)
	6813
	6814	STATIC regnode* S_regpiece(pTHX_ RExC_state_t pRExC_state, I32 flagp, U32 depth)
	6815	__attribute__nonnull__(pTHX_1)
	6816	__attribute__nonnull__(pTHX_2);
	6817	#define PERL_ARGS_ASSERT_REGPIECE \
	6818	assert(pRExC_state); assert(flagp)
	6819
	6820	PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value, const bool strict)
	6821	__attribute__nonnull__(pTHX_1);
	6822	#define PERL_ARGS_ASSERT_REGPPOSIXCC \
	6823	assert(pRExC_state)
	6824
	6825	STATIC void S_regtail(pTHX_ RExC_state_t pRExC_state, regnode p, const regnode *val, U32 depth)
	6826	__attribute__nonnull__(pTHX_1)
	6827	__attribute__nonnull__(pTHX_2)
	6828	__attribute__nonnull__(pTHX_3);
	6829	#define PERL_ARGS_ASSERT_REGTAIL \
	6830	assert(pRExC_state); assert(p); assert(val)
	6831
	6832	STATIC STRLEN S_reguni(pTHX_ const RExC_state_t pRExC_state, UV uv, char s)
	6833	__attribute__nonnull__(pTHX_1)
	6834	__attribute__nonnull__(pTHX_3);
	6835	#define PERL_ARGS_ASSERT_REGUNI \
	6836	assert(pRExC_state); assert(s)
	6837
	6838	STATIC char * S_regwhite(RExC_state_t pRExC_state, char p)
	6839	__attribute__warn_unused_result__
	6840	__attribute__nonnull__(1)
	6841	__attribute__nonnull__(2);
	6842	#define PERL_ARGS_ASSERT_REGWHITE \
	6843	assert(pRExC_state); assert(p)
	6844
	6845	STATIC void S_scan_commit(pTHX_ const RExC_state_t pRExC_state, struct scan_data_t data, SSize_t *minlenp, int is_inf)
	6846	__attribute__nonnull__(pTHX_1)
	6847	__attribute__nonnull__(pTHX_2)
	6848	__attribute__nonnull__(pTHX_3);
	6849	#define PERL_ARGS_ASSERT_SCAN_COMMIT \
	6850	assert(pRExC_state); assert(data); assert(minlenp)
	6851
	6852	STATIC void S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state, regnode* const node, SV* const cp_list, SV* const runtime_defns, SV* const swash, const bool has_user_defined_property)
	6853	__attribute__nonnull__(pTHX_1)
	6854	__attribute__nonnull__(pTHX_2);
	6855	#define PERL_ARGS_ASSERT_SET_ANYOF_ARG \
	6856	assert(pRExC_state); assert(node)
	6857
	6858	PERL_STATIC_INLINE void S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end)
	6859	__attribute__nonnull__(pTHX_1);
	6860	#define PERL_ARGS_ASSERT_SSC_ADD_RANGE \
	6861	assert(ssc)
	6862
	6863	STATIC void S_ssc_and(pTHX_ const RExC_state_t pRExC_state, regnode_ssc ssc, const regnode_ssc *and_with)
	6864	__attribute__nonnull__(pTHX_1)
	6865	__attribute__nonnull__(pTHX_2)
	6866	__attribute__nonnull__(pTHX_3);
	6867	#define PERL_ARGS_ASSERT_SSC_AND \
	6868	assert(pRExC_state); assert(ssc); assert(and_with)
	6869
	6870	STATIC void S_ssc_anything(pTHX_ regnode_ssc *ssc)
	6871	__attribute__nonnull__(pTHX_1);
	6872	#define PERL_ARGS_ASSERT_SSC_ANYTHING \
	6873	assert(ssc)
	6874
	6875	PERL_STATIC_INLINE void S_ssc_clear_locale(pTHX_ regnode_ssc *ssc)
	6876	__attribute__nonnull__(pTHX_1);
	6877	#define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE \
	6878	assert(ssc)
	6879
	6880	PERL_STATIC_INLINE void S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp)
	6881	__attribute__nonnull__(pTHX_1);
	6882	#define PERL_ARGS_ASSERT_SSC_CP_AND \
	6883	assert(ssc)
	6884
	6885	STATIC void S_ssc_finalize(pTHX_ RExC_state_t pRExC_state, regnode_ssc ssc)
	6886	__attribute__nonnull__(pTHX_1)
	6887	__attribute__nonnull__(pTHX_2);
	6888	#define PERL_ARGS_ASSERT_SSC_FINALIZE \
	6889	assert(pRExC_state); assert(ssc)
	6890
	6891	STATIC void S_ssc_flags_and(regnode_ssc *ssc, const U8 and_with)
	6892	__attribute__nonnull__(1);
	6893	#define PERL_ARGS_ASSERT_SSC_FLAGS_AND \
	6894	assert(ssc)
	6895
	6896	STATIC void S_ssc_init(pTHX_ const RExC_state_t pRExC_state, regnode_ssc ssc)
	6897	__attribute__nonnull__(pTHX_1)
	6898	__attribute__nonnull__(pTHX_2);
	6899	#define PERL_ARGS_ASSERT_SSC_INIT \
	6900	assert(pRExC_state); assert(ssc)
	6901
	6902	PERL_STATIC_INLINE void S_ssc_intersection(pTHX_ regnode_ssc ssc, SV const invlist, const bool invert_2nd)
	6903	__attribute__nonnull__(pTHX_1)
	6904	__attribute__nonnull__(pTHX_2);
	6905	#define PERL_ARGS_ASSERT_SSC_INTERSECTION \
	6906	assert(ssc); assert(invlist)
	6907
	6908	STATIC int S_ssc_is_anything(pTHX_ const regnode_ssc *ssc)
	6909	__attribute__warn_unused_result__
	6910	__attribute__nonnull__(pTHX_1);
	6911	#define PERL_ARGS_ASSERT_SSC_IS_ANYTHING \
	6912	assert(ssc)
	6913
	6914	STATIC int S_ssc_is_cp_posixl_init(pTHX_ const RExC_state_t pRExC_state, const regnode_ssc ssc)
	6915	__attribute__warn_unused_result__
	6916	__attribute__nonnull__(pTHX_1)
	6917	__attribute__nonnull__(pTHX_2);
	6918	#define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \
	6919	assert(pRExC_state); assert(ssc)
	6920
	6921	STATIC void S_ssc_or(pTHX_ const RExC_state_t pRExC_state, regnode_ssc ssc, const regnode_ssc *or_with)
	6922	__attribute__nonnull__(pTHX_1)
	6923	__attribute__nonnull__(pTHX_2)
	6924	__attribute__nonnull__(pTHX_3);
	6925	#define PERL_ARGS_ASSERT_SSC_OR \
	6926	assert(pRExC_state); assert(ssc); assert(or_with)
	6927
	6928	PERL_STATIC_INLINE void S_ssc_union(pTHX_ regnode_ssc ssc, SV const invlist, const bool invert_2nd)
	6929	__attribute__nonnull__(pTHX_1)
	6930	__attribute__nonnull__(pTHX_2);
	6931	#define PERL_ARGS_ASSERT_SSC_UNION \
	6932	assert(ssc); assert(invlist)
	6933
	6934	STATIC SSize_t S_study_chunk(pTHX_ RExC_state_t pRExC_state, regnode scanp, SSize_t minlenp, SSize_t deltap, regnode last, struct scan_data_t data, I32 stopparen, U32 recursed_depth, regnode_ssc and_withp, U32 flags, U32 depth)
	6935	__attribute__nonnull__(pTHX_1)
	6936	__attribute__nonnull__(pTHX_2)
	6937	__attribute__nonnull__(pTHX_3)
	6938	__attribute__nonnull__(pTHX_4)
	6939	__attribute__nonnull__(pTHX_5);
	6940	#define PERL_ARGS_ASSERT_STUDY_CHUNK \
	6941	assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last)
	6942
	6943	#endif
	6944	#if defined(PERL_IN_REGCOMP_C) \|\| defined (PERL_IN_DUMP_C)
	6945	PERL_CALLCONV void Perl__invlist_dump(pTHX_ PerlIO file, I32 level, const char const indent, SV* const invlist)
	6946	__attribute__nonnull__(pTHX_1)
	6947	__attribute__nonnull__(pTHX_3)
	6948	__attribute__nonnull__(pTHX_4);
	6949	#define PERL_ARGS_ASSERT__INVLIST_DUMP \
	6950	assert(file); assert(indent); assert(invlist)
	6951
	6952	#endif
	6953	#if defined(PERL_IN_REGCOMP_C) \|\| defined(PERL_IN_PERL_C) \|\| defined(PERL_IN_UTF8_C)
	6954	PERL_CALLCONV SV* Perl__new_invlist_C_array(pTHX_ const UV* const list)
	6955	__attribute__warn_unused_result__
	6956	__attribute__nonnull__(pTHX_1);
	6957	#define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \
	6958	assert(list)
	6959
	6960	#endif
	6961	#if defined(PERL_IN_REGCOMP_C) \|\| defined(PERL_IN_REGEXEC_C) \|\| defined(PERL_IN_UTF8_C)
	6962	PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash)
	6963	__attribute__warn_unused_result__
	6964	__attribute__nonnull__(pTHX_1);
	6965	#define PERL_ARGS_ASSERT__GET_SWASH_INVLIST \
	6966	assert(swash)
	6967
	6968	PERL_STATIC_INLINE bool S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp)
	6969	__attribute__warn_unused_result__
	6970	__attribute__nonnull__(pTHX_1);
	6971	#define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \
	6972	assert(invlist)
	6973
	6974	PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist)
	6975	__attribute__warn_unused_result__
	6976	__attribute__nonnull__(pTHX_1);
	6977	#define PERL_ARGS_ASSERT__INVLIST_CONTENTS \
	6978	assert(invlist)
	6979
	6980	PERL_STATIC_INLINE UV S__invlist_len(pTHX_ SV* const invlist)
	6981	__attribute__warn_unused_result__
	6982	__attribute__nonnull__(pTHX_1);
	6983	#define PERL_ARGS_ASSERT__INVLIST_LEN \
	6984	assert(invlist)
	6985
	6986	PERL_CALLCONV IV Perl__invlist_search(pTHX_ SV* const invlist, const UV cp)
	6987	__attribute__warn_unused_result__
	6988	__attribute__nonnull__(pTHX_1);
	6989	#define PERL_ARGS_ASSERT__INVLIST_SEARCH \
	6990	assert(invlist)
	6991
	6992	PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash)
	6993	__attribute__warn_unused_result__
	6994	__attribute__nonnull__(pTHX_1);
	6995	#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
	6996	assert(swash)
	6997
	6998	PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(pTHX_ SV* invlist)
	6999	__attribute__warn_unused_result__
	7000	__attribute__nonnull__(pTHX_1);
	7001	#define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \
	7002	assert(invlist)
	7003
	7004	#endif
	7005	#if defined(PERL_IN_REGCOMP_C) \|\| defined(PERL_IN_REGEXEC_C) \|\| defined(PERL_IN_UTF8_C) \|\| defined(PERL_IN_TOKE_C)
	7006	PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p)
	7007	__attribute__nonnull__(pTHX_1)
	7008	__attribute__nonnull__(pTHX_2)
	7009	__attribute__nonnull__(pTHX_3);
	7010	#define PERL_ARGS_ASSERT__CORE_SWASH_INIT \
	7011	assert(pkg); assert(name); assert(listsv)
	7012
	7013	#endif
	7014	#if defined(PERL_IN_REGCOMP_C) \|\| defined(PERL_IN_TOKE_C)
	7015	STATIC char* S_form_short_octal_warning(pTHX_ const char * const s, const STRLEN len)
	7016	__attribute__warn_unused_result__
	7017	__attribute__pure__
	7018	__attribute__nonnull__(pTHX_1);
	7019	#define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING \
	7020	assert(s)
	7021
	7022	STATIC char S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning)
	7023	__attribute__warn_unused_result__;
	7024
	7025	STATIC bool S_grok_bslash_o(pTHX_ char** s, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8)
	7026	__attribute__warn_unused_result__
	7027	__attribute__nonnull__(pTHX_1)
	7028	__attribute__nonnull__(pTHX_2)
	7029	__attribute__nonnull__(pTHX_3);
	7030	#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
	7031	assert(s); assert(uv); assert(error_msg)
	7032
	7033	PERL_STATIC_INLINE bool S_grok_bslash_x(pTHX_ char** s, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8)
	7034	__attribute__warn_unused_result__
	7035	__attribute__nonnull__(pTHX_1)
	7036	__attribute__nonnull__(pTHX_2)
	7037	__attribute__nonnull__(pTHX_3);
	7038	#define PERL_ARGS_ASSERT_GROK_BSLASH_X \
	7039	assert(s); assert(uv); assert(error_msg)
	7040
	7041	PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s, const bool rbrace_must_be_escaped)
	7042	__attribute__warn_unused_result__
	7043	__attribute__pure__
	7044	__attribute__nonnull__(pTHX_1);
	7045	#define PERL_ARGS_ASSERT_REGCURLY \
	7046	assert(s)
	7047
	7048	#endif
	7049	#if defined(PERL_IN_REGCOMP_C) \|\| defined(PERL_IN_UTF8_C)
	7050	PERL_CALLCONV SV* Perl__add_range_to_invlist(pTHX_ SV* invlist, const UV start, const UV end)
	7051	__attribute__warn_unused_result__;
	7052
	7053	/* PERL_CALLCONV void _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i)
	7054	__attribute__nonnull__(pTHX_1)
	7055	__attribute__nonnull__(pTHX_2)
	7056	__attribute__nonnull__(pTHX_3); */
	7057
	7058	PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i)
	7059	__attribute__nonnull__(pTHX_2)
	7060	__attribute__nonnull__(pTHX_4);
	7061	#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \
	7062	assert(b); assert(i)
	7063
	7064	PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist)
	7065	__attribute__nonnull__(pTHX_1);
	7066	#define PERL_ARGS_ASSERT__INVLIST_INVERT \
	7067	assert(invlist)
	7068
	7069	PERL_CALLCONV void Perl__invlist_populate_swatch(pTHX_ SV* const invlist, const UV start, const UV end, U8* swatch)
	7070	__attribute__nonnull__(pTHX_1)
	7071	__attribute__nonnull__(pTHX_4);
	7072	#define PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH \
	7073	assert(invlist); assert(swatch)
	7074
	7075	/* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result)
	7076	__attribute__nonnull__(pTHX_1)
	7077	__attribute__nonnull__(pTHX_2)
	7078	__attribute__nonnull__(pTHX_3); */
	7079
	7080	/* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output)
	7081	__attribute__nonnull__(pTHX_2)
	7082	__attribute__nonnull__(pTHX_3); */
	7083
	7084	PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output)
	7085	__attribute__nonnull__(pTHX_2)
	7086	__attribute__nonnull__(pTHX_4);
	7087	#define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \
	7088	assert(b); assert(output)
	7089
	7090	PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size)
	7091	__attribute__warn_unused_result__;
	7092
	7093	PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr)
	7094	__attribute__warn_unused_result__
	7095	__attribute__nonnull__(pTHX_3);
	7096	#define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \
	7097	assert(other_elements_ptr)
	7098
	7099	PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash)
	7100	__attribute__warn_unused_result__
	7101	__attribute__nonnull__(pTHX_1);
	7102	#define PERL_ARGS_ASSERT__SWASH_TO_INVLIST \
	7103	assert(swash)
	7104
	7105	#endif
	7106	#if defined(PERL_IN_REGEXEC_C)
	7107	STATIC SV* S_core_regclass_swash(pTHX_ const regexp prog, const struct regnode node, bool doinit, SV **listsvp)
	7108	__attribute__warn_unused_result__
	7109	__attribute__nonnull__(pTHX_2);
	7110	#define PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH \
	7111	assert(node)
	7112
	7113	STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode c, char s, const char strend, regmatch_info reginfo)
	7114	__attribute__warn_unused_result__
	7115	__attribute__nonnull__(pTHX_1)
	7116	__attribute__nonnull__(pTHX_2)
	7117	__attribute__nonnull__(pTHX_3)
	7118	__attribute__nonnull__(pTHX_4);
	7119	#define PERL_ARGS_ASSERT_FIND_BYCLASS \
	7120	assert(prog); assert(c); assert(s); assert(strend)
	7121
	7122	STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character)
	7123	__attribute__warn_unused_result__;
	7124
	7125	STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character)
	7126	__attribute__warn_unused_result__
	7127	__attribute__nonnull__(pTHX_2);
	7128	#define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \
	7129	assert(character)
	7130
	7131	STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp rex, const regnode scan)
	7132	__attribute__warn_unused_result__
	7133	__attribute__nonnull__(pTHX_1)
	7134	__attribute__nonnull__(pTHX_2);
	7135	#define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \
	7136	assert(rex); assert(scan)
	7137
	7138	STATIC void S_regcppop(pTHX_ regexp rex, U32 maxopenparen_p)
	7139	__attribute__nonnull__(pTHX_1)
	7140	__attribute__nonnull__(pTHX_2);
	7141	#define PERL_ARGS_ASSERT_REGCPPOP \
	7142	assert(rex); assert(maxopenparen_p)
	7143
	7144	STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen)
	7145	__attribute__nonnull__(pTHX_1);
	7146	#define PERL_ARGS_ASSERT_REGCPPUSH \
	7147	assert(rex)
	7148
	7149	STATIC U8* S_reghop3(U8 s, SSize_t off, const U8 lim)
	7150	__attribute__warn_unused_result__
	7151	__attribute__nonnull__(1)
	7152	__attribute__nonnull__(3);
	7153	#define PERL_ARGS_ASSERT_REGHOP3 \
	7154	assert(s); assert(lim)
	7155
	7156	STATIC U8* S_reghopmaybe3(U8 s, SSize_t off, const U8 lim)
	7157	__attribute__warn_unused_result__
	7158	__attribute__nonnull__(1)
	7159	__attribute__nonnull__(3);
	7160	#define PERL_ARGS_ASSERT_REGHOPMAYBE3 \
	7161	assert(s); assert(lim)
	7162
	7163	STATIC bool S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, const U8 * const p_end, bool const utf8_target)
	7164	__attribute__warn_unused_result__
	7165	__attribute__nonnull__(pTHX_2)
	7166	__attribute__nonnull__(pTHX_3)
	7167	__attribute__nonnull__(pTHX_4);
	7168	#define PERL_ARGS_ASSERT_REGINCLASS \
	7169	assert(n); assert(p); assert(p_end)
	7170
	7171	STATIC SSize_t S_regmatch(pTHX_ regmatch_info reginfo, char startpos, regnode *prog)
	7172	__attribute__warn_unused_result__
	7173	__attribute__nonnull__(pTHX_1)
	7174	__attribute__nonnull__(pTHX_2)
	7175	__attribute__nonnull__(pTHX_3);
	7176	#define PERL_ARGS_ASSERT_REGMATCH \
	7177	assert(reginfo); assert(startpos); assert(prog)
	7178
	7179	STATIC I32 S_regrepeat(pTHX_ regexp prog, char startposp, const regnode p, regmatch_info *const reginfo, I32 max, int depth)
	7180	__attribute__warn_unused_result__
	7181	__attribute__nonnull__(pTHX_1)
	7182	__attribute__nonnull__(pTHX_2)
	7183	__attribute__nonnull__(pTHX_3)
	7184	__attribute__nonnull__(pTHX_4);
	7185	#define PERL_ARGS_ASSERT_REGREPEAT \
	7186	assert(prog); assert(startposp); assert(p); assert(reginfo)
	7187
	7188	STATIC I32 S_regtry(pTHX_ regmatch_info reginfo, char *startposp)
	7189	__attribute__warn_unused_result__
	7190	__attribute__nonnull__(pTHX_1)
	7191	__attribute__nonnull__(pTHX_2);
	7192	#define PERL_ARGS_ASSERT_REGTRY \
	7193	assert(reginfo); assert(startposp)
	7194
	7195	STATIC bool S_to_byte_substr(pTHX_ regexp * prog)
	7196	__attribute__nonnull__(pTHX_1);
	7197	#define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \
	7198	assert(prog)
	7199
	7200	STATIC void S_to_utf8_substr(pTHX_ regexp * prog)
	7201	__attribute__nonnull__(pTHX_1);
	7202	#define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \
	7203	assert(prog)
	7204
	7205	# if defined(XXX_dmq)
	7206	STATIC U8* S_reghop4(U8 s, SSize_t off, const U8 llim, const U8 *rlim)
	7207	__attribute__warn_unused_result__
	7208	__attribute__nonnull__(1)
	7209	__attribute__nonnull__(3)
	7210	__attribute__nonnull__(4);
	7211	#define PERL_ARGS_ASSERT_REGHOP4 \
	7212	assert(s); assert(llim); assert(rlim)
	7213
	7214	# endif
	7215	#endif
	7216	#if defined(PERL_IN_SCOPE_C)
	7217	STATIC void S_save_pushptri32ptr(pTHX_ void const ptr1, const I32 i, void const ptr2, const int type);
	7218	STATIC SV* S_save_scalar_at(pTHX_ SV **sptr, const U32 flags)
	7219	__attribute__nonnull__(pTHX_1);
	7220	#define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \
	7221	assert(sptr)
	7222
	7223	#endif
	7224	#if defined(PERL_IN_SV_C)
	7225	STATIC char * S_F0convert(NV nv, char const endbuf, STRLEN const len)
	7226	__attribute__nonnull__(2)
	7227	__attribute__nonnull__(3);
	7228	#define PERL_ARGS_ASSERT_F0CONVERT \
	7229	assert(endbuf); assert(len)
	7230
	7231	STATIC void S_anonymise_cv_maybe(pTHX_ GV gv, CV cv)
	7232	__attribute__nonnull__(pTHX_1)
	7233	__attribute__nonnull__(pTHX_2);
	7234	#define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \
	7235	assert(gv); assert(cv)
	7236
	7237	STATIC void S_assert_uft8_cache_coherent(pTHX_ const char const func, STRLEN from_cache, STRLEN real, SV const sv)
	7238	__attribute__nonnull__(pTHX_1)
	7239	__attribute__nonnull__(pTHX_4);
	7240	#define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \
	7241	assert(func); assert(sv)
	7242
	7243	STATIC bool S_curse(pTHX_ SV * const sv, const bool check_refcnt)
	7244	__attribute__nonnull__(pTHX_1);
	7245	#define PERL_ARGS_ASSERT_CURSE \
	7246	assert(sv)
	7247
	7248	STATIC I32 S_expect_number(pTHX_ char **const pattern)
	7249	__attribute__warn_unused_result__
	7250	__attribute__nonnull__(pTHX_1);
	7251	#define PERL_ARGS_ASSERT_EXPECT_NUMBER \
	7252	assert(pattern)
	7253
	7254	STATIC I32 S_find_array_subscript(pTHX_ const AV const av, const SV const val)
	7255	__attribute__nonnull__(pTHX_2);
	7256	#define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \
	7257	assert(val)
	7258
	7259	STATIC SV * S_find_hash_subscript(pTHX_ const HV const hv, const SV const val)
	7260	__attribute__nonnull__(pTHX_2);
	7261	#define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \
	7262	assert(val)
	7263
	7264	STATIC SV* S_find_uninit_var(pTHX_ const OP const obase, const SV const uninit_sv, bool top);
	7265	STATIC bool S_glob_2number(pTHX_ GV* const gv)
	7266	__attribute__nonnull__(pTHX_1);
	7267	#define PERL_ARGS_ASSERT_GLOB_2NUMBER \
	7268	assert(gv)
	7269
	7270	STATIC void S_glob_assign_glob(pTHX_ SV const dstr, SV const sstr, const int dtype)
	7271	__attribute__nonnull__(pTHX_1)
	7272	__attribute__nonnull__(pTHX_2);
	7273	#define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \
	7274	assert(dstr); assert(sstr)
	7275
	7276	STATIC void S_glob_assign_ref(pTHX_ SV const dstr, SV const sstr)
	7277	__attribute__nonnull__(pTHX_1)
	7278	__attribute__nonnull__(pTHX_2);
	7279	#define PERL_ARGS_ASSERT_GLOB_ASSIGN_REF \
	7280	assert(dstr); assert(sstr)
	7281
	7282	STATIC SV * S_more_sv(pTHX);
	7283	STATIC void S_not_a_number(pTHX_ SV *const sv)
	7284	__attribute__nonnull__(pTHX_1);
	7285	#define PERL_ARGS_ASSERT_NOT_A_NUMBER \
	7286	assert(sv)
	7287
	7288	STATIC void S_not_incrementable(pTHX_ SV *const sv)
	7289	__attribute__nonnull__(pTHX_1);
	7290	#define PERL_ARGS_ASSERT_NOT_INCREMENTABLE \
	7291	assert(sv)
	7292
	7293	STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t const tbl, const void const sv)
	7294	__attribute__warn_unused_result__
	7295	__attribute__nonnull__(1);
	7296	#define PERL_ARGS_ASSERT_PTR_TABLE_FIND \
	7297	assert(tbl)
	7298
	7299	STATIC bool S_sv_2iuv_common(pTHX_ SV *const sv)
	7300	__attribute__nonnull__(pTHX_1);
	7301	#define PERL_ARGS_ASSERT_SV_2IUV_COMMON \
	7302	assert(sv)
	7303
	7304	STATIC void S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flags)
	7305	__attribute__nonnull__(pTHX_1);
	7306	#define PERL_ARGS_ASSERT_SV_ADD_ARENA \
	7307	assert(ptr)
	7308
	7309	STATIC const char * S_sv_display(pTHX_ SV const sv, char tmpbuf, STRLEN tmpbuf_size)
	7310	__attribute__nonnull__(pTHX_1)
	7311	__attribute__nonnull__(pTHX_2);
	7312	#define PERL_ARGS_ASSERT_SV_DISPLAY \
	7313	assert(sv); assert(tmpbuf)
	7314
	7315	STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 const s, const U8 const target, const U8 *end, STRLEN endu)
	7316	__attribute__nonnull__(pTHX_1)
	7317	__attribute__nonnull__(pTHX_2)
	7318	__attribute__nonnull__(pTHX_3);
	7319	#define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \
	7320	assert(s); assert(target); assert(end)
	7321
	7322	STATIC STRLEN S_sv_pos_u2b_cached(pTHX_ SV const sv, MAGIC const mgp, const U8 const start, const U8 *const send, STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0)
	7323	__attribute__nonnull__(pTHX_1)
	7324	__attribute__nonnull__(pTHX_2)
	7325	__attribute__nonnull__(pTHX_3)
	7326	__attribute__nonnull__(pTHX_4);
	7327	#define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \
	7328	assert(sv); assert(mgp); assert(start); assert(send)
	7329
	7330	STATIC STRLEN S_sv_pos_u2b_forwards(const U8 const start, const U8 const send, STRLEN const uoffset, bool const at_end)
	7331	__attribute__nonnull__(1)
	7332	__attribute__nonnull__(2)
	7333	__attribute__nonnull__(3)
	7334	__attribute__nonnull__(4);
	7335	#define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \
	7336	assert(start); assert(send); assert(uoffset); assert(at_end)
	7337
	7338	STATIC STRLEN S_sv_pos_u2b_midway(const U8 const start, const U8 send, STRLEN uoffset, const STRLEN uend)
	7339	__attribute__nonnull__(1)
	7340	__attribute__nonnull__(2);
	7341	#define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \
	7342	assert(start); assert(send)
	7343
	7344	PERL_STATIC_INLINE void S_sv_unglob(pTHX_ SV *const sv, U32 flags)
	7345	__attribute__nonnull__(pTHX_1);
	7346	#define PERL_ARGS_ASSERT_SV_UNGLOB \
	7347	assert(sv)
	7348
	7349	STATIC char * S_uiv_2buf(char const buf, const IV iv, UV uv, const int is_uv, char *const peob)
	7350	__attribute__warn_unused_result__
	7351	__attribute__nonnull__(1)
	7352	__attribute__nonnull__(5);
	7353	#define PERL_ARGS_ASSERT_UIV_2BUF \
	7354	assert(buf); assert(peob)
	7355
	7356	STATIC void S_utf8_mg_len_cache_update(pTHX_ SV const sv, MAGIC *const mgp, const STRLEN ulen)
	7357	__attribute__nonnull__(pTHX_1)
	7358	__attribute__nonnull__(pTHX_2);
	7359	#define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \
	7360	assert(sv); assert(mgp)
	7361
	7362	STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV const sv, MAGIC *const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen)
	7363	__attribute__nonnull__(pTHX_1)
	7364	__attribute__nonnull__(pTHX_2);
	7365	#define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \
	7366	assert(sv); assert(mgp)
	7367
	7368	STATIC I32 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask)
	7369	__attribute__nonnull__(pTHX_1);
	7370	#define PERL_ARGS_ASSERT_VISIT \
	7371	assert(f)
	7372
	7373	# if defined(PERL_OLD_COPY_ON_WRITE)
	7374	STATIC void S_sv_release_COW(pTHX_ SV sv, const char pvx, SV *after)
	7375	__attribute__nonnull__(pTHX_1)
	7376	__attribute__nonnull__(pTHX_2)
	7377	__attribute__nonnull__(pTHX_3);
	7378	#define PERL_ARGS_ASSERT_SV_RELEASE_COW \
	7379	assert(sv); assert(pvx); assert(after)
	7380
	7381	# endif
	7382	# if defined(USE_ITHREADS)
	7383	STATIC SV* S_sv_dup_common(pTHX_ const SV const sstr, CLONE_PARAMS const param)
	7384	__attribute__warn_unused_result__
	7385	__attribute__nonnull__(pTHX_1)
	7386	__attribute__nonnull__(pTHX_2);
	7387	#define PERL_ARGS_ASSERT_SV_DUP_COMMON \
	7388	assert(sstr); assert(param)
	7389
	7390	STATIC SV ** S_sv_dup_inc_multiple(pTHX_ SV const source, SV *dest, SSize_t items, CLONE_PARAMS const param)
	7391	__attribute__nonnull__(pTHX_1)
	7392	__attribute__nonnull__(pTHX_2)
	7393	__attribute__nonnull__(pTHX_4);
	7394	#define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \
	7395	assert(source); assert(dest); assert(param)
	7396
	7397	STATIC void S_unreferenced_to_tmp_stack(pTHX_ AV *const unreferenced)
	7398	__attribute__nonnull__(pTHX_1);
	7399	#define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \
	7400	assert(unreferenced)
	7401
	7402	# endif
	7403	#endif
	7404	#if defined(PERL_IN_SV_C) \|\| defined (PERL_IN_OP_C)
	7405	PERL_CALLCONV SV * Perl_varname(pTHX_ const GV const gv, const char gvtype, PADOFFSET targ, const SV const keyname, I32 aindex, int subscript_type)
	7406	__attribute__warn_unused_result__;
	7407
	7408	#endif
	7409	#if defined(PERL_IN_TOKE_C)
	7410	STATIC int S_ao(pTHX_ int toketype);
	7411	STATIC void S_check_uni(pTHX);
	7412	STATIC void S_checkcomma(pTHX_ const char s, const char name, const char *what)
	7413	__attribute__nonnull__(pTHX_1)
	7414	__attribute__nonnull__(pTHX_2)
	7415	__attribute__nonnull__(pTHX_3);
	7416	#define PERL_ARGS_ASSERT_CHECKCOMMA \
	7417	assert(s); assert(name); assert(what)
	7418
	7419	STATIC int S_deprecate_commaless_var_list(pTHX);
	7420	STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append)
	7421	__attribute__warn_unused_result__
	7422	__attribute__nonnull__(pTHX_1);
	7423	#define PERL_ARGS_ASSERT_FILTER_GETS \
	7424	assert(sv)
	7425
	7426	STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len)
	7427	__attribute__warn_unused_result__
	7428	__attribute__nonnull__(pTHX_1);
	7429	#define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \
	7430	assert(pkgname)
	7431
	7432	STATIC void S_force_ident(pTHX_ const char *s, int kind)
	7433	__attribute__nonnull__(pTHX_1);
	7434	#define PERL_ARGS_ASSERT_FORCE_IDENT \
	7435	assert(s)
	7436
	7437	STATIC void S_force_ident_maybe_lex(pTHX_ char pit);
	7438	STATIC void S_force_next(pTHX_ I32 type);
	7439	STATIC char* S_force_strict_version(pTHX_ char *s)
	7440	__attribute__nonnull__(pTHX_1);
	7441	#define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \
	7442	assert(s)
	7443
	7444	STATIC char* S_force_version(pTHX_ char *s, int guessing)
	7445	__attribute__nonnull__(pTHX_1);
	7446	#define PERL_ARGS_ASSERT_FORCE_VERSION \
	7447	assert(s)
	7448
	7449	STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack)
	7450	__attribute__nonnull__(pTHX_1);
	7451	#define PERL_ARGS_ASSERT_FORCE_WORD \
	7452	assert(start)
	7453
	7454	PERL_STATIC_INLINE SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e)
	7455	__attribute__warn_unused_result__
	7456	__attribute__nonnull__(pTHX_1)
	7457	__attribute__nonnull__(pTHX_2);
	7458	#define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \
	7459	assert(s); assert(e)
	7460
	7461	STATIC void S_incline(pTHX_ const char *s)
	7462	__attribute__nonnull__(pTHX_1);
	7463	#define PERL_ARGS_ASSERT_INCLINE \
	7464	assert(s)
	7465
	7466	STATIC int S_intuit_method(pTHX_ char s, GV gv, CV *cv)
	7467	__attribute__nonnull__(pTHX_1);
	7468	#define PERL_ARGS_ASSERT_INTUIT_METHOD \
	7469	assert(s)
	7470
	7471	STATIC int S_intuit_more(pTHX_ char *s)
	7472	__attribute__nonnull__(pTHX_1);
	7473	#define PERL_ARGS_ASSERT_INTUIT_MORE \
	7474	assert(s)
	7475
	7476	STATIC I32 S_lop(pTHX_ I32 f, int x, char *s)
	7477	__attribute__nonnull__(pTHX_3);
	7478	#define PERL_ARGS_ASSERT_LOP \
	7479	assert(s)
	7480
	7481	PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s)
	7482	__attribute__noreturn__;
	7483
	7484	STATIC SV* S_new_constant(pTHX_ const char s, STRLEN len, const char key, STRLEN keylen, SV sv, SV pv, const char *type, STRLEN typelen)
	7485	__attribute__nonnull__(pTHX_3)
	7486	__attribute__nonnull__(pTHX_5);
	7487	#define PERL_ARGS_ASSERT_NEW_CONSTANT \
	7488	assert(key); assert(sv)
	7489
	7490	STATIC void S_no_op(pTHX_ const char const what, char s)
	7491	__attribute__nonnull__(pTHX_1);
	7492	#define PERL_ARGS_ASSERT_NO_OP \
	7493	assert(what)
	7494
	7495	STATIC void S_parse_ident(pTHX_ char s, char d, char * const e, int allow_package, bool is_utf8)
	7496	__attribute__nonnull__(pTHX_1)
	7497	__attribute__nonnull__(pTHX_2)
	7498	__attribute__nonnull__(pTHX_3);
	7499	#define PERL_ARGS_ASSERT_PARSE_IDENT \
	7500	assert(s); assert(d); assert(e)
	7501
	7502	STATIC int S_pending_ident(pTHX);
	7503	STATIC char* S_scan_const(pTHX_ char *start)
	7504	__attribute__warn_unused_result__
	7505	__attribute__nonnull__(pTHX_1);
	7506	#define PERL_ARGS_ASSERT_SCAN_CONST \
	7507	assert(start)
	7508
	7509	STATIC char* S_scan_formline(pTHX_ char *s)
	7510	__attribute__warn_unused_result__
	7511	__attribute__nonnull__(pTHX_1);
	7512	#define PERL_ARGS_ASSERT_SCAN_FORMLINE \
	7513	assert(s)
	7514
	7515	STATIC char* S_scan_heredoc(pTHX_ char *s)
	7516	__attribute__warn_unused_result__
	7517	__attribute__nonnull__(pTHX_1);
	7518	#define PERL_ARGS_ASSERT_SCAN_HEREDOC \
	7519	assert(s)
	7520
	7521	STATIC char* S_scan_ident(pTHX_ char s, char dest, STRLEN destlen, I32 ck_uni)
	7522	__attribute__nonnull__(pTHX_1)
	7523	__attribute__nonnull__(pTHX_2);
	7524	#define PERL_ARGS_ASSERT_SCAN_IDENT \
	7525	assert(s); assert(dest)
	7526
	7527	STATIC char* S_scan_inputsymbol(pTHX_ char *start)
	7528	__attribute__warn_unused_result__
	7529	__attribute__nonnull__(pTHX_1);
	7530	#define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \
	7531	assert(start)
	7532
	7533	STATIC char* S_scan_pat(pTHX_ char *start, I32 type)
	7534	__attribute__warn_unused_result__
	7535	__attribute__nonnull__(pTHX_1);
	7536	#define PERL_ARGS_ASSERT_SCAN_PAT \
	7537	assert(start)
	7538
	7539	STATIC char* S_scan_str(pTHX_ char start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching, char *delimp)
	7540	__attribute__warn_unused_result__
	7541	__attribute__nonnull__(pTHX_1);
	7542	#define PERL_ARGS_ASSERT_SCAN_STR \
	7543	assert(start)
	7544
	7545	STATIC char* S_scan_subst(pTHX_ char *start)
	7546	__attribute__warn_unused_result__
	7547	__attribute__nonnull__(pTHX_1);
	7548	#define PERL_ARGS_ASSERT_SCAN_SUBST \
	7549	assert(start)
	7550
	7551	STATIC char* S_scan_trans(pTHX_ char *start)
	7552	__attribute__warn_unused_result__
	7553	__attribute__nonnull__(pTHX_1);
	7554	#define PERL_ARGS_ASSERT_SCAN_TRANS \
	7555	assert(start)
	7556
	7557	STATIC char* S_scan_word(pTHX_ char s, char dest, STRLEN destlen, int allow_package, STRLEN *slp)
	7558	__attribute__nonnull__(pTHX_1)
	7559	__attribute__nonnull__(pTHX_2)
	7560	__attribute__nonnull__(pTHX_5);
	7561	#define PERL_ARGS_ASSERT_SCAN_WORD \
	7562	assert(s); assert(dest); assert(slp)
	7563
	7564	STATIC char* S_skipspace_flags(pTHX_ char *s, U32 flags)
	7565	__attribute__warn_unused_result__
	7566	__attribute__nonnull__(pTHX_1);
	7567	#define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \
	7568	assert(s)
	7569
	7570	STATIC I32 S_sublex_done(pTHX)
	7571	__attribute__warn_unused_result__;
	7572
	7573	STATIC I32 S_sublex_push(pTHX)
	7574	__attribute__warn_unused_result__;
	7575
	7576	STATIC I32 S_sublex_start(pTHX)
	7577	__attribute__warn_unused_result__;
	7578
	7579	STATIC char* S_swallow_bom(pTHX_ U8 *s)
	7580	__attribute__warn_unused_result__
	7581	__attribute__nonnull__(pTHX_1);
	7582	#define PERL_ARGS_ASSERT_SWALLOW_BOM \
	7583	assert(s)
	7584
	7585	STATIC char * S_tokenize_use(pTHX_ int is_use, char *s)
	7586	__attribute__warn_unused_result__
	7587	__attribute__nonnull__(pTHX_2);
	7588	#define PERL_ARGS_ASSERT_TOKENIZE_USE \
	7589	assert(s)
	7590
	7591	STATIC SV* S_tokeq(pTHX_ SV *sv)
	7592	__attribute__nonnull__(pTHX_1);
	7593	#define PERL_ARGS_ASSERT_TOKEQ \
	7594	assert(sv)
	7595
	7596	STATIC void S_update_debugger_info(pTHX_ SV orig_sv, const char const buf, STRLEN len);
	7597	STATIC int S_yywarn(pTHX_ const char *const s, U32 flags)
	7598	__attribute__nonnull__(pTHX_1);
	7599	#define PERL_ARGS_ASSERT_YYWARN \
	7600	assert(s)
	7601
	7602	# if defined(PERL_MAD)
	7603	STATIC void S_curmad(pTHX_ char slot, SV *sv);
	7604	STATIC char* S_skipspace0(pTHX_ char *s)
	7605	__attribute__nonnull__(pTHX_1);
	7606	#define PERL_ARGS_ASSERT_SKIPSPACE0 \
	7607	assert(s)
	7608
	7609	STATIC char* S_skipspace1(pTHX_ char *s)
	7610	__attribute__nonnull__(pTHX_1);
	7611	#define PERL_ARGS_ASSERT_SKIPSPACE1 \
	7612	assert(s)
	7613
	7614	STATIC char* S_skipspace2(pTHX_ char s, SV *sv)
	7615	__attribute__nonnull__(pTHX_1);
	7616	#define PERL_ARGS_ASSERT_SKIPSPACE2 \
	7617	assert(s)
	7618
	7619	STATIC void S_start_force(pTHX_ int where);
	7620	# endif
	7621	#endif
	7622	#if defined(PERL_IN_UNIVERSAL_C)
	7623	STATIC bool S_isa_lookup(pTHX_ HV stash, const char const name, STRLEN len, U32 flags)
	7624	__attribute__nonnull__(pTHX_1)
	7625	__attribute__nonnull__(pTHX_2);
	7626	#define PERL_ARGS_ASSERT_ISA_LOOKUP \
	7627	assert(stash); assert(name)
	7628
	7629	#endif
	7630	#if defined(PERL_IN_UTF8_C)
	7631	STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp)
	7632	__attribute__warn_unused_result__
	7633	__attribute__nonnull__(pTHX_1)
	7634	__attribute__nonnull__(pTHX_3)
	7635	__attribute__nonnull__(pTHX_4);
	7636	#define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \
	7637	assert(p); assert(ustrp); assert(lenp)
	7638
	7639	PERL_STATIC_INLINE STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len)
	7640	__attribute__warn_unused_result__
	7641	__attribute__nonnull__(1);
	7642	#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \
	7643	assert(s)
	7644
	7645	PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 const p, SV swash, const char const swashname, SV* const invlist)
	7646	__attribute__warn_unused_result__
	7647	__attribute__nonnull__(pTHX_1)
	7648	__attribute__nonnull__(pTHX_2)
	7649	__attribute__nonnull__(pTHX_3);
	7650	#define PERL_ARGS_ASSERT_IS_UTF8_COMMON \
	7651	assert(p); assert(swash); assert(swashname)
	7652
	7653	STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span)
	7654	__attribute__warn_unused_result__
	7655	__attribute__nonnull__(pTHX_1);
	7656	#define PERL_ARGS_ASSERT_SWATCH_GET \
	7657	assert(swash)
	7658
	7659	STATIC U8 S_to_lower_latin1(pTHX_ const U8 c, U8 p, STRLEN lenp)
	7660	__attribute__warn_unused_result__;
	7661
	7662	#endif
	7663	#if defined(PERL_IN_UTF8_C) \|\| defined(PERL_IN_PP_C)
	7664	PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 p, STRLEN lenp, const char S_or_s)
	7665	__attribute__nonnull__(pTHX_2)
	7666	__attribute__nonnull__(pTHX_3);
	7667	#define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \
	7668	assert(p); assert(lenp)
	7669
	7670	#endif
	7671	#if defined(PERL_IN_UTF8_C) \|\| defined(PERL_IN_REGCOMP_C) \|\| defined(PERL_IN_REGEXEC_C)
	7672	PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 p, STRLEN lenp, const unsigned int flags)
	7673	__attribute__nonnull__(pTHX_2)
	7674	__attribute__nonnull__(pTHX_3);
	7675	#define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \
	7676	assert(p); assert(lenp)
	7677
	7678	#endif
	7679	#if defined(PERL_IN_UTIL_C)
	7680	STATIC bool S_ckwarn_common(pTHX_ U32 w);
	7681	STATIC bool S_invoke_exception_hook(pTHX_ SV *ex, bool warn);
	7682	STATIC SV* S_mess_alloc(pTHX);
	7683	STATIC SV * S_with_queued_errors(pTHX_ SV *ex)
	7684	__attribute__nonnull__(pTHX_1);
	7685	#define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \
	7686	assert(ex)
	7687
	7688	# if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL)
	7689	STATIC void S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char type_name, const SV sv, Malloc_t oldalloc, Malloc_t newalloc, const char filename, const int linenumber, const char funcname)
	7690	__attribute__nonnull__(4)
	7691	__attribute__nonnull__(8)
	7692	__attribute__nonnull__(10);
	7693	#define PERL_ARGS_ASSERT_MEM_LOG_COMMON \
	7694	assert(type_name); assert(filename); assert(funcname)
	7695
	7696	# endif
	7697	#endif
	7698	#if defined(PERL_MAD)
	7699	PERL_CALLCONV void Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot);
	7700	PERL_CALLCONV void Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot);
	7701	PERL_CALLCONV void Perl_do_op_xmldump(pTHX_ I32 level, PerlIO file, const OP o)
	7702	__attribute__nonnull__(pTHX_2);
	7703	#define PERL_ARGS_ASSERT_DO_OP_XMLDUMP \
	7704	assert(file)
	7705
	7706	PERL_CALLCONV void Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO file, const PMOP pm)
	7707	__attribute__nonnull__(pTHX_2);
	7708	#define PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP \
	7709	assert(file)
	7710
	7711	PERL_CALLCONV void Perl_mad_free(pTHX_ MADPROP* mp);
	7712	PERL_CALLCONV int Perl_madlex(pTHX);
	7713	PERL_CALLCONV int Perl_madparse(pTHX_ int gramtype);
	7714	PERL_CALLCONV OP* Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
	7715	PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen);
	7716	PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv)
	7717	__attribute__nonnull__(pTHX_2);
	7718	#define PERL_ARGS_ASSERT_NEWMADSV \
	7719	assert(sv)
	7720
	7721	PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop);
	7722	PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot);
	7723	PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot);
	7724	PERL_CALLCONV void Perl_op_xmldump(pTHX_ const OP *o)
	7725	__attribute__nonnull__(pTHX_1);
	7726	#define PERL_ARGS_ASSERT_OP_XMLDUMP \
	7727	assert(o)
	7728
	7729	PERL_CALLCONV OP* Perl_package(pTHX_ OP* o)
	7730	__attribute__nonnull__(pTHX_1);
	7731	#define PERL_ARGS_ASSERT_PACKAGE \
	7732	assert(o)
	7733
	7734	PERL_CALLCONV void Perl_pad_peg(const char* s)
	7735	__attribute__nonnull__(1);
	7736	#define PERL_ARGS_ASSERT_PAD_PEG \
	7737	assert(s)
	7738
	7739	PERL_CALLCONV void Perl_pmop_xmldump(pTHX_ const PMOP* pm);
	7740	PERL_CALLCONV void Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot);
	7741	PERL_CALLCONV char* Perl_sv_catxmlpv(pTHX_ SV dsv, const char pv, int utf8)
	7742	__attribute__nonnull__(pTHX_1)
	7743	__attribute__nonnull__(pTHX_2);
	7744	#define PERL_ARGS_ASSERT_SV_CATXMLPV \
	7745	assert(dsv); assert(pv)
	7746
	7747	PERL_CALLCONV char* Perl_sv_catxmlpvn(pTHX_ SV dsv, const char pv, STRLEN len, int utf8)
	7748	__attribute__nonnull__(pTHX_1)
	7749	__attribute__nonnull__(pTHX_2);
	7750	#define PERL_ARGS_ASSERT_SV_CATXMLPVN \
	7751	assert(dsv); assert(pv)
	7752
	7753	PERL_CALLCONV char* Perl_sv_catxmlsv(pTHX_ SV dsv, SV ssv)
	7754	__attribute__nonnull__(pTHX_1)
	7755	__attribute__nonnull__(pTHX_2);
	7756	#define PERL_ARGS_ASSERT_SV_CATXMLSV \
	7757	assert(dsv); assert(ssv)
	7758
	7759	PERL_CALLCONV char* Perl_sv_xmlpeek(pTHX_ SV* sv)
	7760	__attribute__nonnull__(pTHX_1);
	7761	#define PERL_ARGS_ASSERT_SV_XMLPEEK \
	7762	assert(sv)
	7763
	7764	PERL_CALLCONV void Perl_token_free(pTHX_ TOKEN *tk)
	7765	__attribute__nonnull__(pTHX_1);
	7766	#define PERL_ARGS_ASSERT_TOKEN_FREE \
	7767	assert(tk)
	7768
	7769	PERL_CALLCONV void Perl_token_getmad(pTHX_ TOKEN tk, OP o, char slot)
	7770	__attribute__nonnull__(pTHX_1);
	7771	#define PERL_ARGS_ASSERT_TOKEN_GETMAD \
	7772	assert(tk)
	7773
	7774	PERL_CALLCONV OP * Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg)
	7775	__attribute__nonnull__(pTHX_4);
	7776	#define PERL_ARGS_ASSERT_UTILIZE \
	7777	assert(idop)
	7778
	7779	PERL_CALLCONV void Perl_xmldump_all(pTHX);
	7780	PERL_CALLCONV void Perl_xmldump_all_perl(pTHX_ bool justperl);
	7781	PERL_CALLCONV void Perl_xmldump_eval(pTHX);
	7782	PERL_CALLCONV void Perl_xmldump_form(pTHX_ const GV* gv)
	7783	__attribute__nonnull__(pTHX_1);
	7784	#define PERL_ARGS_ASSERT_XMLDUMP_FORM \
	7785	assert(gv)
	7786
	7787	PERL_CALLCONV void Perl_xmldump_indent(pTHX_ I32 level, PerlIO file, const char pat, ...)
	7788	__attribute__format__(__printf__,pTHX_3,pTHX_4)
	7789	__attribute__nonnull__(pTHX_2)
	7790	__attribute__nonnull__(pTHX_3);
	7791	#define PERL_ARGS_ASSERT_XMLDUMP_INDENT \
	7792	assert(file); assert(pat)
	7793
	7794	PERL_CALLCONV void Perl_xmldump_packsubs(pTHX_ const HV* stash)
	7795	__attribute__nonnull__(pTHX_1);
	7796	#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS \
	7797	assert(stash)
	7798
	7799	PERL_CALLCONV void Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl)
	7800	__attribute__nonnull__(pTHX_1);
	7801	#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \
	7802	assert(stash)
	7803
	7804	PERL_CALLCONV void Perl_xmldump_sub(pTHX_ const GV* gv)
	7805	__attribute__nonnull__(pTHX_1);
	7806	#define PERL_ARGS_ASSERT_XMLDUMP_SUB \
	7807	assert(gv)
	7808
	7809	PERL_CALLCONV void Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl)
	7810	__attribute__nonnull__(pTHX_1);
	7811	#define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL \
	7812	assert(gv)
	7813
	7814	PERL_CALLCONV void Perl_xmldump_vindent(pTHX_ I32 level, PerlIO file, const char pat, va_list *args)
	7815	__attribute__nonnull__(pTHX_2)
	7816	__attribute__nonnull__(pTHX_3);
	7817	#define PERL_ARGS_ASSERT_XMLDUMP_VINDENT \
	7818	assert(file); assert(pat)
	7819
	7820	#endif
	7821	#if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
	7822	STATIC void S_pidgone(pTHX_ Pid_t pid, int status);
	7823	#endif
	7824	#if defined(UNLINK_ALL_VERSIONS)
	7825	PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f)
	7826	__attribute__nonnull__(pTHX_1);
	7827	#define PERL_ARGS_ASSERT_UNLNK \
	7828	assert(f)
	7829
	7830	#endif
	7831	#if defined(USE_ITHREADS)
	7832	PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv)
	7833	__attribute__nonnull__(pTHX_1);
	7834	#define PERL_ARGS_ASSERT_ALLOCCOPSTASH \
	7835	assert(hv)
	7836
	7837	PERL_CALLCONV void* Perl_any_dup(pTHX_ void* v, const PerlInterpreter* proto_perl)
	7838	__attribute__warn_unused_result__
	7839	__attribute__nonnull__(pTHX_2);
	7840	#define PERL_ARGS_ASSERT_ANY_DUP \
	7841	assert(proto_perl)
	7842
	7843	PERL_CALLCONV void Perl_clone_params_del(CLONE_PARAMS *param)
	7844	__attribute__nonnull__(1);
	7845	#define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \
	7846	assert(param)
	7847
	7848	PERL_CALLCONV CLONE_PARAMS * Perl_clone_params_new(PerlInterpreter const from, PerlInterpreter const to)
	7849	__attribute__malloc__
	7850	__attribute__warn_unused_result__
	7851	__attribute__nonnull__(1)
	7852	__attribute__nonnull__(2);
	7853	#define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW \
	7854	assert(from); assert(to)
	7855
	7856	PERL_CALLCONV PERL_CONTEXT* Perl_cx_dup(pTHX_ PERL_CONTEXT* cx, I32 ix, I32 max, CLONE_PARAMS* param)
	7857	__attribute__warn_unused_result__
	7858	__attribute__nonnull__(pTHX_4);
	7859	#define PERL_ARGS_ASSERT_CX_DUP \
	7860	assert(param)
	7861
	7862	PERL_CALLCONV DIR* Perl_dirp_dup(pTHX_ DIR const dp, CLONE_PARAMS const param)
	7863	__attribute__warn_unused_result__
	7864	__attribute__nonnull__(pTHX_2);
	7865	#define PERL_ARGS_ASSERT_DIRP_DUP \
	7866	assert(param)
	7867
	7868	PERL_CALLCONV PerlIO* Perl_fp_dup(pTHX_ PerlIO const fp, const char type, CLONE_PARAMS const param)
	7869	__attribute__nonnull__(pTHX_3);
	7870	#define PERL_ARGS_ASSERT_FP_DUP \
	7871	assert(param)
	7872
	7873	PERL_CALLCONV GP* Perl_gp_dup(pTHX_ GP const gp, CLONE_PARAMS const param)
	7874	__attribute__warn_unused_result__
	7875	__attribute__nonnull__(pTHX_2);
	7876	#define PERL_ARGS_ASSERT_GP_DUP \
	7877	assert(param)
	7878
	7879	PERL_CALLCONV HE* Perl_he_dup(pTHX_ const HE* e, bool shared, CLONE_PARAMS* param)
	7880	__attribute__warn_unused_result__
	7881	__attribute__nonnull__(pTHX_3);
	7882	#define PERL_ARGS_ASSERT_HE_DUP \
	7883	assert(param)
	7884
	7885	PERL_CALLCONV HEK* Perl_hek_dup(pTHX_ HEK* e, CLONE_PARAMS* param)
	7886	__attribute__warn_unused_result__
	7887	__attribute__nonnull__(pTHX_2);
	7888	#define PERL_ARGS_ASSERT_HEK_DUP \
	7889	assert(param)
	7890
	7891	PERL_CALLCONV MAGIC* Perl_mg_dup(pTHX_ MAGIC mg, CLONE_PARAMS const param)
	7892	__attribute__warn_unused_result__
	7893	__attribute__nonnull__(pTHX_2);
	7894	#define PERL_ARGS_ASSERT_MG_DUP \
	7895	assert(param)
	7896
	7897	PERL_CALLCONV struct mro_meta* Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param)
	7898	__attribute__nonnull__(pTHX_1)
	7899	__attribute__nonnull__(pTHX_2);
	7900	#define PERL_ARGS_ASSERT_MRO_META_DUP \
	7901	assert(smeta); assert(param)
	7902
	7903	PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv)
	7904	__attribute__malloc__
	7905	__attribute__warn_unused_result__
	7906	__attribute__nonnull__(pTHX_3);
	7907	#define PERL_ARGS_ASSERT_NEWPADOP \
	7908	assert(sv)
	7909
	7910	PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST srcpad, CLONE_PARAMS param)
	7911	__attribute__warn_unused_result__
	7912	__attribute__nonnull__(pTHX_2);
	7913	#define PERL_ARGS_ASSERT_PADLIST_DUP \
	7914	assert(param)
	7915
	7916	PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser const proto, CLONE_PARAMS const param)
	7917	__attribute__nonnull__(pTHX_2);
	7918	#define PERL_ARGS_ASSERT_PARSER_DUP \
	7919	assert(param)
	7920
	7921	PERL_CALLCONV PerlInterpreter* perl_clone(PerlInterpreter *proto_perl, UV flags)
	7922	__attribute__nonnull__(1);
	7923	#define PERL_ARGS_ASSERT_PERL_CLONE \
	7924	assert(proto_perl)
	7925
	7926	PERL_CALLCONV void Perl_re_dup_guts(pTHX_ const REGEXP sstr, REGEXP dstr, CLONE_PARAMS* param)
	7927	__attribute__nonnull__(pTHX_1)
	7928	__attribute__nonnull__(pTHX_2)
	7929	__attribute__nonnull__(pTHX_3);
	7930	#define PERL_ARGS_ASSERT_RE_DUP_GUTS \
	7931	assert(sstr); assert(dstr); assert(param)
	7932
	7933	PERL_CALLCONV void* Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS* param)
	7934	__attribute__nonnull__(pTHX_1)
	7935	__attribute__nonnull__(pTHX_2);
	7936	#define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \
	7937	assert(r); assert(param)
	7938
	7939	PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV const dstr, const SV const sstr, CLONE_PARAMS *const param)
	7940	__attribute__nonnull__(pTHX_1)
	7941	__attribute__nonnull__(pTHX_2)
	7942	__attribute__nonnull__(pTHX_3);
	7943	#define PERL_ARGS_ASSERT_RVPV_DUP \
	7944	assert(dstr); assert(sstr); assert(param)
	7945
	7946	PERL_CALLCONV PERL_SI* Perl_si_dup(pTHX_ PERL_SI* si, CLONE_PARAMS* param)
	7947	__attribute__warn_unused_result__
	7948	__attribute__nonnull__(pTHX_2);
	7949	#define PERL_ARGS_ASSERT_SI_DUP \
	7950	assert(param)
	7951
	7952	PERL_CALLCONV ANY* Perl_ss_dup(pTHX_ PerlInterpreter* proto_perl, CLONE_PARAMS* param)
	7953	__attribute__malloc__
	7954	__attribute__warn_unused_result__
	7955	__attribute__nonnull__(pTHX_1)
	7956	__attribute__nonnull__(pTHX_2);
	7957	#define PERL_ARGS_ASSERT_SS_DUP \
	7958	assert(proto_perl); assert(param)
	7959
	7960	PERL_CALLCONV SV* Perl_sv_dup(pTHX_ const SV const sstr, CLONE_PARAMS const param)
	7961	__attribute__warn_unused_result__
	7962	__attribute__nonnull__(pTHX_2);
	7963	#define PERL_ARGS_ASSERT_SV_DUP \
	7964	assert(param)
	7965
	7966	PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV const sstr, CLONE_PARAMS const param)
	7967	__attribute__warn_unused_result__
	7968	__attribute__nonnull__(pTHX_2);
	7969	#define PERL_ARGS_ASSERT_SV_DUP_INC \
	7970	assert(param)
	7971
	7972	#endif
	7973	#if defined(USE_LOCALE_COLLATE)
	7974	PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg)
	7975	__attribute__nonnull__(pTHX_1)
	7976	__attribute__nonnull__(pTHX_2);
	7977	#define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \
	7978	assert(sv); assert(mg)
	7979
	7980	PERL_CALLCONV char* Perl_mem_collxfrm(pTHX_ const char* s, STRLEN len, STRLEN* xlen)
	7981	__attribute__nonnull__(pTHX_1)
	7982	__attribute__nonnull__(pTHX_3);
	7983	#define PERL_ARGS_ASSERT_MEM_COLLXFRM \
	7984	assert(s); assert(xlen)
	7985
	7986	/* PERL_CALLCONV char* sv_collxfrm(pTHX_ SV const sv, STRLEN const nxp)
	7987	__attribute__nonnull__(pTHX_1)
	7988	__attribute__nonnull__(pTHX_2); */
	7989
	7990	PERL_CALLCONV char* Perl_sv_collxfrm_flags(pTHX_ SV const sv, STRLEN const nxp, I32 const flags)
	7991	__attribute__nonnull__(pTHX_1)
	7992	__attribute__nonnull__(pTHX_2);
	7993	#define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \
	7994	assert(sv); assert(nxp)
	7995
	7996	#endif
	7997	#if defined(USE_PERLIO)
	7998	PERL_CALLCONV void Perl_PerlIO_clearerr(pTHX_ PerlIO *f);
	7999	PERL_CALLCONV int Perl_PerlIO_close(pTHX_ PerlIO *f);
	8000	PERL_CALLCONV int Perl_PerlIO_eof(pTHX_ PerlIO *f);
	8001	PERL_CALLCONV int Perl_PerlIO_error(pTHX_ PerlIO *f);
	8002	PERL_CALLCONV int Perl_PerlIO_fileno(pTHX_ PerlIO *f);
	8003	PERL_CALLCONV int Perl_PerlIO_fill(pTHX_ PerlIO *f);
	8004	PERL_CALLCONV int Perl_PerlIO_flush(pTHX_ PerlIO *f);
	8005	PERL_CALLCONV STDCHAR * Perl_PerlIO_get_base(pTHX_ PerlIO *f);
	8006	PERL_CALLCONV SSize_t Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
	8007	__attribute__warn_unused_result__;
	8008
	8009	PERL_CALLCONV SSize_t Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
	8010	__attribute__warn_unused_result__;
	8011
	8012	PERL_CALLCONV STDCHAR * Perl_PerlIO_get_ptr(pTHX_ PerlIO *f);
	8013	PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO f, void vbuf, Size_t count)
	8014	__attribute__nonnull__(pTHX_2);
	8015	#define PERL_ARGS_ASSERT_PERLIO_READ \
	8016	assert(vbuf)
	8017
	8018	PERL_CALLCONV int Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
	8019	PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt);
	8020	PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO f, STDCHAR ptr, SSize_t cnt);
	8021	PERL_CALLCONV void Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f);
	8022	PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX)
	8023	__attribute__warn_unused_result__;
	8024
	8025	PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX)
	8026	__attribute__warn_unused_result__;
	8027
	8028	PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX)
	8029	__attribute__warn_unused_result__;
	8030
	8031	PERL_CALLCONV Off_t Perl_PerlIO_tell(pTHX_ PerlIO *f);
	8032	PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO f, const void vbuf, Size_t count)
	8033	__attribute__nonnull__(pTHX_2);
	8034	#define PERL_ARGS_ASSERT_PERLIO_UNREAD \
	8035	assert(vbuf)
	8036
	8037	PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO f, const void vbuf, Size_t count)
	8038	__attribute__nonnull__(pTHX_2);
	8039	#define PERL_ARGS_ASSERT_PERLIO_WRITE \
	8040	assert(vbuf)
	8041
	8042	#endif
	8043	#if defined(WIN32)
	8044	PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname)
	8045	__attribute__noreturn__
	8046	__attribute__nonnull__(1);
	8047	#define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \
	8048	assert(fname)
	8049
	8050	#endif
	8051	#if defined(WIN32) \|\| defined(__SYMBIAN32__) \|\| defined(VMS)
	8052	PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV* really, SV mark, SV sp)
	8053	__attribute__nonnull__(pTHX_2)
	8054	__attribute__nonnull__(pTHX_3);
	8055	#define PERL_ARGS_ASSERT_DO_ASPAWN \
	8056	assert(mark); assert(sp)
	8057
	8058	PERL_CALLCONV int Perl_do_spawn(pTHX_ char* cmd)
	8059	__attribute__nonnull__(pTHX_1);
	8060	#define PERL_ARGS_ASSERT_DO_SPAWN \
	8061	assert(cmd)
	8062
	8063	PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd)
	8064	__attribute__nonnull__(pTHX_1);
	8065	#define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \
	8066	assert(cmd)
	8067
	8068	#endif
	8069	#if defined(_MSC_VER)
	8070	PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
	8071	__attribute__nonnull__(pTHX_1)
	8072	__attribute__nonnull__(pTHX_2);
	8073	#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \
	8074	assert(sv); assert(mg)
	8075
	8076	#endif
	8077	#ifdef PERL_CORE
	8078	# include "pp_proto.h"
	8079	#endif
	8080	END_EXTERN_C
	8081
	8082	/* ex: set ro: */