static long syz_proconfig_reset__sys_module_dm_mod_parameters_swap_bios()
{
	char command[256];
	sprintf(command, "echo 2048 > /sys/module/dm_mod/parameters/swap_bios");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_dm_mod_parameters_kcopyd_subjob_size_kb(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/dm_mod/parameters/kcopyd_subjob_size_kb", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_dm_mod_parameters_kcopyd_subjob_size_kb()
{
	char command[256];
	sprintf(command, "echo 512 > /sys/module/dm_mod/parameters/kcopyd_subjob_size_kb");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_dm_mod_parameters_dm_mq_nr_hw_queues(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/dm_mod/parameters/dm_mq_nr_hw_queues", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_dm_mod_parameters_dm_mq_nr_hw_queues()
{
	char command[256];
	sprintf(command, "echo 1 > /sys/module/dm_mod/parameters/dm_mq_nr_hw_queues");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_dm_mod_parameters_dm_mq_queue_depth(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/dm_mod/parameters/dm_mq_queue_depth", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_dm_mod_parameters_dm_mq_queue_depth()
{
	char command[256];
	sprintf(command, "echo 2048 > /sys/module/dm_mod/parameters/dm_mq_queue_depth");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_i915_parameters_request_timeout_ms(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/i915/parameters/request_timeout_ms", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_i915_parameters_request_timeout_ms()
{
	char command[256];
	sprintf(command, "echo 20000 > /sys/module/i915/parameters/request_timeout_ms");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_libata_parameters_ignore_hpa(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/libata/parameters/ignore_hpa", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_libata_parameters_ignore_hpa()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/libata/parameters/ignore_hpa");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_libata_parameters_acpi_gtf_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/libata/parameters/acpi_gtf_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_libata_parameters_acpi_gtf_filter()
{
	char command[256];
	sprintf(command, "echo 7 > /sys/module/libata/parameters/acpi_gtf_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_sg_parameters_scatter_elem_sz(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/sg/parameters/scatter_elem_sz", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_sg_parameters_scatter_elem_sz()
{
	char command[256];
	sprintf(command, "echo 32768 > /sys/module/sg/parameters/scatter_elem_sz");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_sg_parameters_def_reserved_size(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/sg/parameters/def_reserved_size", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_sg_parameters_def_reserved_size()
{
	char command[256];
	sprintf(command, "echo 32768 > /sys/module/sg/parameters/def_reserved_size");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_sg_parameters_allow_dio(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/sg/parameters/allow_dio", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_sg_parameters_allow_dio()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/sg/parameters/allow_dio");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_psmouse_parameters_resetafter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/psmouse/parameters/resetafter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_psmouse_parameters_resetafter()
{
	char command[256];
	sprintf(command, "echo 5 > /sys/module/psmouse/parameters/resetafter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_psmouse_parameters_resolution(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/psmouse/parameters/resolution", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_psmouse_parameters_resolution()
{
	char command[256];
	sprintf(command, "echo 200 > /sys/module/psmouse/parameters/resolution");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_psmouse_parameters_synaptics_intertouch(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/psmouse/parameters/synaptics_intertouch", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_psmouse_parameters_synaptics_intertouch()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/psmouse/parameters/synaptics_intertouch");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_psmouse_parameters_rate(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/psmouse/parameters/rate", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_psmouse_parameters_rate()
{
	char command[256];
	sprintf(command, "echo 100 > /sys/module/psmouse/parameters/rate");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_psmouse_parameters_resync_time(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/psmouse/parameters/resync_time", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_psmouse_parameters_resync_time()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/psmouse/parameters/resync_time");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_ttm_parameters_dma32_pages_limit(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/ttm/parameters/dma32_pages_limit", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_ttm_parameters_dma32_pages_limit()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/ttm/parameters/dma32_pages_limit");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_ttm_parameters_pages_limit(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/ttm/parameters/pages_limit", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_ttm_parameters_pages_limit()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/ttm/parameters/pages_limit");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_ttm_parameters_page_pool_size(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/ttm/parameters/page_pool_size", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_ttm_parameters_page_pool_size()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/ttm/parameters/page_pool_size");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_dm_mirror_parameters_raid1_resync_throttle(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/dm_mirror/parameters/raid1_resync_throttle", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_dm_mirror_parameters_raid1_resync_throttle()
{
	char command[256];
	sprintf(command, "echo 100 > /sys/module/dm_mirror/parameters/raid1_resync_throttle");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_acpi_parameters_aml_debug_output(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/acpi/parameters/aml_debug_output", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_acpi_parameters_aml_debug_output()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/acpi/parameters/aml_debug_output");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_acpi_parameters_ec_polling_guard(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/acpi/parameters/ec_polling_guard", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_acpi_parameters_ec_polling_guard()
{
	char command[256];
	sprintf(command, "echo 550 > /sys/module/acpi/parameters/ec_polling_guard");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_acpi_parameters_ec_storm_threshold(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/acpi/parameters/ec_storm_threshold", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_acpi_parameters_ec_storm_threshold()
{
	char command[256];
	sprintf(command, "echo 8 > /sys/module/acpi/parameters/ec_storm_threshold");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_acpi_parameters_ec_max_queries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/acpi/parameters/ec_max_queries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_acpi_parameters_ec_max_queries()
{
	char command[256];
	sprintf(command, "echo 16 > /sys/module/acpi/parameters/ec_max_queries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_acpi_parameters_ec_delay(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/acpi/parameters/ec_delay", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_acpi_parameters_ec_delay()
{
	char command[256];
	sprintf(command, "echo 500 > /sys/module/acpi/parameters/ec_delay");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_clocksource_parameters_verify_n_cpus(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/clocksource/parameters/verify_n_cpus", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_clocksource_parameters_verify_n_cpus()
{
	char command[256];
	sprintf(command, "echo 8 > /sys/module/clocksource/parameters/verify_n_cpus");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_rng_core_parameters_current_quality(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/rng_core/parameters/current_quality", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_rng_core_parameters_current_quality()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/rng_core/parameters/current_quality");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_rng_core_parameters_default_quality(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/rng_core/parameters/default_quality", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_rng_core_parameters_default_quality()
{
	char command[256];
	sprintf(command, "echo 1024 > /sys/module/rng_core/parameters/default_quality");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_virtio_blk_parameters_num_request_queues(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/virtio_blk/parameters/num_request_queues", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_virtio_blk_parameters_num_request_queues()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/virtio_blk/parameters/num_request_queues");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_virtio_blk_parameters_poll_queues(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/virtio_blk/parameters/poll_queues", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_virtio_blk_parameters_poll_queues()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/virtio_blk/parameters/poll_queues");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_cfg80211_parameters_bss_entries_limit(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/cfg80211/parameters/bss_entries_limit", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_cfg80211_parameters_bss_entries_limit()
{
	char command[256];
	sprintf(command, "echo 1000 > /sys/module/cfg80211/parameters/bss_entries_limit");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_nfs_parameters_send_implementation_id(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/nfs/parameters/send_implementation_id", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_nfs_parameters_send_implementation_id()
{
	char command[256];
	sprintf(command, "echo 1 > /sys/module/nfs/parameters/send_implementation_id");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_nfs_parameters_nfs_access_max_cachesize(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/nfs/parameters/nfs_access_max_cachesize", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_nfs_parameters_nfs_access_max_cachesize()
{
	char command[256];
	sprintf(command, "echo 4194304 > /sys/module/nfs/parameters/nfs_access_max_cachesize");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_nfs_parameters_nfs_mountpoint_expiry_timeout(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/nfs/parameters/nfs_mountpoint_expiry_timeout", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_nfs_parameters_nfs_mountpoint_expiry_timeout()
{
	char command[256];
	sprintf(command, "echo 500 > /sys/module/nfs/parameters/nfs_mountpoint_expiry_timeout");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_nfs_parameters_max_session_cb_slots(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/nfs/parameters/max_session_cb_slots", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_nfs_parameters_max_session_cb_slots()
{
	char command[256];
	sprintf(command, "echo 16 > /sys/module/nfs/parameters/max_session_cb_slots");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_nfs_parameters_max_session_slots(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/nfs/parameters/max_session_slots", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_nfs_parameters_max_session_slots()
{
	char command[256];
	sprintf(command, "echo 64 > /sys/module/nfs/parameters/max_session_slots");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_nfs_parameters_callback_tcpport(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/nfs/parameters/callback_tcpport", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_nfs_parameters_callback_tcpport()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/nfs/parameters/callback_tcpport");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_nfs_parameters_nfs_idmap_cache_timeout(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/nfs/parameters/nfs_idmap_cache_timeout", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_nfs_parameters_nfs_idmap_cache_timeout()
{
	char command[256];
	sprintf(command, "echo 600 > /sys/module/nfs/parameters/nfs_idmap_cache_timeout");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_nfs_parameters_callback_nr_threads(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/nfs/parameters/callback_nr_threads", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_nfs_parameters_callback_nr_threads()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/nfs/parameters/callback_nr_threads");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_workqueue_parameters_cpu_intensive_thresh_us(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/workqueue/parameters/cpu_intensive_thresh_us", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_workqueue_parameters_cpu_intensive_thresh_us()
{
	char command[256];
	sprintf(command, "echo 10000 > /sys/module/workqueue/parameters/cpu_intensive_thresh_us");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_workqueue_parameters_watchdog_thresh(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/workqueue/parameters/watchdog_thresh", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_workqueue_parameters_watchdog_thresh()
{
	char command[256];
	sprintf(command, "echo 30 > /sys/module/workqueue/parameters/watchdog_thresh");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_workqueue_parameters_panic_on_stall(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/workqueue/parameters/panic_on_stall", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_workqueue_parameters_panic_on_stall()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/workqueue/parameters/panic_on_stall");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_sr_mod_parameters_xa_test(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/sr_mod/parameters/xa_test", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_sr_mod_parameters_xa_test()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/sr_mod/parameters/xa_test");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_drm_parameters_timestamp_precision_usec(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/drm/parameters/timestamp_precision_usec", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_drm_parameters_timestamp_precision_usec()
{
	char command[256];
	sprintf(command, "echo 20 > /sys/module/drm/parameters/timestamp_precision_usec");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_drm_parameters_debug(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/drm/parameters/debug", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_drm_parameters_debug()
{
	char command[256];
	sprintf(command, "echo 0 > /sys/module/drm/parameters/debug");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_set__sys_module_drm_parameters_vblankoffdelay(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /sys/module/drm/parameters/vblankoffdelay", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_proconfig_reset__sys_module_drm_parameters_vblankoffdelay()
{
	char command[256];
	sprintf(command, "echo 5000 > /sys/module/drm/parameters/vblankoffdelay");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_abi_vsyscall32(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/abi/vsyscall32", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_abi_vsyscall32()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/abi/vsyscall32");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_debug_exception_trace(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/debug/exception-trace", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_debug_exception_trace()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/debug/exception-trace");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_debug_kprobes_optimization(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/debug/kprobes-optimization", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_debug_kprobes_optimization()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/debug/kprobes-optimization");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_cdrom_autoclose(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/cdrom/autoclose", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_cdrom_autoclose()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/dev/cdrom/autoclose");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_cdrom_autoeject(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/cdrom/autoeject", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_cdrom_autoeject()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/dev/cdrom/autoeject");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_cdrom_check_media(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/cdrom/check_media", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_cdrom_check_media()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/dev/cdrom/check_media");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_cdrom_debug(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/cdrom/debug", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_cdrom_debug()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/dev/cdrom/debug");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_cdrom_lock(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/cdrom/lock", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_cdrom_lock()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/dev/cdrom/lock");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_hpet_max_user_freq(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/hpet/max-user-freq", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_hpet_max_user_freq()
{
	char command[256];
	sprintf(command, "echo 64 > /proc/sys/dev/hpet/max-user-freq");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_i915_oa_max_sample_rate(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/i915/oa_max_sample_rate", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_i915_oa_max_sample_rate()
{
	char command[256];
	sprintf(command, "echo 100000 > /proc/sys/dev/i915/oa_max_sample_rate");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_i915_perf_stream_paranoid(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/i915/perf_stream_paranoid", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_i915_perf_stream_paranoid()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/dev/i915/perf_stream_paranoid");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_mac_hid_mouse_button2_keycode(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/mac_hid/mouse_button2_keycode", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_mac_hid_mouse_button2_keycode()
{
	char command[256];
	sprintf(command, "echo 97 > /proc/sys/dev/mac_hid/mouse_button2_keycode");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_mac_hid_mouse_button3_keycode(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/mac_hid/mouse_button3_keycode", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_mac_hid_mouse_button3_keycode()
{
	char command[256];
	sprintf(command, "echo 100 > /proc/sys/dev/mac_hid/mouse_button3_keycode");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_mac_hid_mouse_button_emulation(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/mac_hid/mouse_button_emulation", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_mac_hid_mouse_button_emulation()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/dev/mac_hid/mouse_button_emulation");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_raid_speed_limit_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/raid/speed_limit_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_raid_speed_limit_max()
{
	char command[256];
	sprintf(command, "echo 200000 > /proc/sys/dev/raid/speed_limit_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_raid_speed_limit_min(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/raid/speed_limit_min", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_raid_speed_limit_min()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/dev/raid/speed_limit_min");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_scsi_logging_level(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/scsi/logging_level", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_scsi_logging_level()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/dev/scsi/logging_level");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_tty_ldisc_autoload(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/tty/ldisc_autoload", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_tty_ldisc_autoload()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/dev/tty/ldisc_autoload");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_dev_tty_legacy_tiocsti(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/dev/tty/legacy_tiocsti", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_dev_tty_legacy_tiocsti()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/dev/tty/legacy_tiocsti");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_aio_max_nr(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/aio-max-nr", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_aio_max_nr()
{
	char command[256];
	sprintf(command, "echo 65536 > /proc/sys/fs/aio-max-nr");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_dentry_negative(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/dentry-negative", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_dentry_negative()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/dentry-negative");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_dir_notify_enable(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/dir-notify-enable", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_dir_notify_enable()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/fs/dir-notify-enable");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_file_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/file-max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_file_max()
{
	char command[256];
	sprintf(command, "echo 9223372036854775807 > /proc/sys/fs/file-max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_lease_break_time(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/lease-break-time", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_lease_break_time()
{
	char command[256];
	sprintf(command, "echo 45 > /proc/sys/fs/lease-break-time");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_leases_enable(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/leases-enable", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_leases_enable()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/fs/leases-enable");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_mount_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/mount-max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_mount_max()
{
	char command[256];
	sprintf(command, "echo 100000 > /proc/sys/fs/mount-max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nr_open(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nr_open", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nr_open()
{
	char command[256];
	sprintf(command, "echo 1048576 > /proc/sys/fs/nr_open");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_overflowgid(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/overflowgid", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_overflowgid()
{
	char command[256];
	sprintf(command, "echo 65534 > /proc/sys/fs/overflowgid");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_overflowuid(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/overflowuid", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_overflowuid()
{
	char command[256];
	sprintf(command, "echo 65534 > /proc/sys/fs/overflowuid");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_pipe_max_size(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/pipe-max-size", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_pipe_max_size()
{
	char command[256];
	sprintf(command, "echo 1048576 > /proc/sys/fs/pipe-max-size");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_pipe_user_pages_hard(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/pipe-user-pages-hard", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_pipe_user_pages_hard()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/pipe-user-pages-hard");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_pipe_user_pages_soft(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/pipe-user-pages-soft", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_pipe_user_pages_soft()
{
	char command[256];
	sprintf(command, "echo 16384 > /proc/sys/fs/pipe-user-pages-soft");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_protected_fifos(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/protected_fifos", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_protected_fifos()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/fs/protected_fifos");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_protected_hardlinks(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/protected_hardlinks", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_protected_hardlinks()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/fs/protected_hardlinks");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_protected_regular(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/protected_regular", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_protected_regular()
{
	char command[256];
	sprintf(command, "echo 2 > /proc/sys/fs/protected_regular");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_protected_symlinks(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/protected_symlinks", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_protected_symlinks()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/fs/protected_symlinks");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_suid_dumpable(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/suid_dumpable", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_suid_dumpable()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/suid_dumpable");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_epoll_max_user_watches(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/epoll/max_user_watches", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_epoll_max_user_watches()
{
	char command[256];
	sprintf(command, "echo 369241 > /proc/sys/fs/epoll/max_user_watches");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_inotify_max_queued_events(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/inotify/max_queued_events", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_inotify_max_queued_events()
{
	char command[256];
	sprintf(command, "echo 16384 > /proc/sys/fs/inotify/max_queued_events");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_inotify_max_user_instances(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/inotify/max_user_instances", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_inotify_max_user_instances()
{
	char command[256];
	sprintf(command, "echo 128 > /proc/sys/fs/inotify/max_user_instances");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_inotify_max_user_watches(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/inotify/max_user_watches", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_inotify_max_user_watches()
{
	char command[256];
	sprintf(command, "echo 8192 > /proc/sys/fs/inotify/max_user_watches");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_mqueue_msg_default(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/mqueue/msg_default", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_mqueue_msg_default()
{
	char command[256];
	sprintf(command, "echo 10 > /proc/sys/fs/mqueue/msg_default");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_mqueue_msg_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/mqueue/msg_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_mqueue_msg_max()
{
	char command[256];
	sprintf(command, "echo 10 > /proc/sys/fs/mqueue/msg_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_mqueue_msgsize_default(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/mqueue/msgsize_default", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_mqueue_msgsize_default()
{
	char command[256];
	sprintf(command, "echo 8192 > /proc/sys/fs/mqueue/msgsize_default");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_mqueue_msgsize_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/mqueue/msgsize_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_mqueue_msgsize_max()
{
	char command[256];
	sprintf(command, "echo 8192 > /proc/sys/fs/mqueue/msgsize_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_mqueue_queues_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/mqueue/queues_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_mqueue_queues_max()
{
	char command[256];
	sprintf(command, "echo 256 > /proc/sys/fs/mqueue/queues_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_idmap_cache_timeout(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/idmap_cache_timeout", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_idmap_cache_timeout()
{
	char command[256];
	sprintf(command, "echo 600 > /proc/sys/fs/nfs/idmap_cache_timeout");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nfs_callback_tcpport(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nfs_callback_tcpport", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nfs_callback_tcpport()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/nfs/nfs_callback_tcpport");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nfs_congestion_kb(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nfs_congestion_kb", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nfs_congestion_kb()
{
	char command[256];
	sprintf(command, "echo 41152 > /proc/sys/fs/nfs/nfs_congestion_kb");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nfs_mountpoint_timeout(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nfs_mountpoint_timeout", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nfs_mountpoint_timeout()
{
	char command[256];
	sprintf(command, "echo 500 > /proc/sys/fs/nfs/nfs_mountpoint_timeout");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nlm_grace_period(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nlm_grace_period", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nlm_grace_period()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/nfs/nlm_grace_period");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nlm_tcpport(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nlm_tcpport", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nlm_tcpport()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/nfs/nlm_tcpport");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nlm_timeout(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nlm_timeout", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nlm_timeout()
{
	char command[256];
	sprintf(command, "echo 10 > /proc/sys/fs/nfs/nlm_timeout");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nlm_udpport(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nlm_udpport", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nlm_udpport()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/nfs/nlm_udpport");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nsm_local_state(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nsm_local_state", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nsm_local_state()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/nfs/nsm_local_state");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_fs_nfs_nsm_use_hostnames(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/fs/nfs/nsm_use_hostnames", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_fs_nfs_nsm_use_hostnames()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/fs/nfs/nsm_use_hostnames");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_nf_conntrack_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/nf_conntrack_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_nf_conntrack_max()
{
	char command[256];
	sprintf(command, "echo 65536 > /proc/sys/net/nf_conntrack_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_busy_poll(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/busy_poll", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_busy_poll()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/busy_poll");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_busy_read(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/busy_read", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_busy_read()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/busy_read");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_dev_weight(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/dev_weight", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_dev_weight()
{
	char command[256];
	sprintf(command, "echo 64 > /proc/sys/net/core/dev_weight");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_dev_weight_rx_bias(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/dev_weight_rx_bias", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_dev_weight_rx_bias()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/core/dev_weight_rx_bias");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_dev_weight_tx_bias(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/dev_weight_tx_bias", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_dev_weight_tx_bias()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/core/dev_weight_tx_bias");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_devconf_inherit_init_net(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/devconf_inherit_init_net", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_devconf_inherit_init_net()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/devconf_inherit_init_net");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_fb_tunnels_only_for_init_net(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/fb_tunnels_only_for_init_net", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_fb_tunnels_only_for_init_net()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/fb_tunnels_only_for_init_net");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_flow_limit_cpu_bitmap(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/flow_limit_cpu_bitmap", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_flow_limit_cpu_bitmap()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/flow_limit_cpu_bitmap");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_flow_limit_table_len(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/flow_limit_table_len", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_flow_limit_table_len()
{
	char command[256];
	sprintf(command, "echo 4096 > /proc/sys/net/core/flow_limit_table_len");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_gro_normal_batch(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/gro_normal_batch", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_gro_normal_batch()
{
	char command[256];
	sprintf(command, "echo 8 > /proc/sys/net/core/gro_normal_batch");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_high_order_alloc_disable(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/high_order_alloc_disable", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_high_order_alloc_disable()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/high_order_alloc_disable");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_max_skb_frags(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/max_skb_frags", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_max_skb_frags()
{
	char command[256];
	sprintf(command, "echo 17 > /proc/sys/net/core/max_skb_frags");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_mem_pcpu_rsv(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/mem_pcpu_rsv", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_mem_pcpu_rsv()
{
	char command[256];
	sprintf(command, "echo 256 > /proc/sys/net/core/mem_pcpu_rsv");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_message_burst(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/message_burst", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_message_burst()
{
	char command[256];
	sprintf(command, "echo 10 > /proc/sys/net/core/message_burst");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_message_cost(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/message_cost", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_message_cost()
{
	char command[256];
	sprintf(command, "echo 5 > /proc/sys/net/core/message_cost");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_netdev_budget(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/netdev_budget", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_netdev_budget()
{
	char command[256];
	sprintf(command, "echo 300 > /proc/sys/net/core/netdev_budget");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_netdev_budget_usecs(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/netdev_budget_usecs", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_netdev_budget_usecs()
{
	char command[256];
	sprintf(command, "echo 2000 > /proc/sys/net/core/netdev_budget_usecs");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_netdev_max_backlog(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/netdev_max_backlog", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_netdev_max_backlog()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/net/core/netdev_max_backlog");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_netdev_tstamp_prequeue(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/netdev_tstamp_prequeue", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_netdev_tstamp_prequeue()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/core/netdev_tstamp_prequeue");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_netdev_unregister_timeout_secs(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/netdev_unregister_timeout_secs", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_netdev_unregister_timeout_secs()
{
	char command[256];
	sprintf(command, "echo 10 > /proc/sys/net/core/netdev_unregister_timeout_secs");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_optmem_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/optmem_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_optmem_max()
{
	char command[256];
	sprintf(command, "echo 131072 > /proc/sys/net/core/optmem_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_rmem_default(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/rmem_default", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_rmem_default()
{
	char command[256];
	sprintf(command, "echo 212992 > /proc/sys/net/core/rmem_default");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_rmem_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/rmem_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_rmem_max()
{
	char command[256];
	sprintf(command, "echo 212992 > /proc/sys/net/core/rmem_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_rps_default_mask(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/rps_default_mask", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_rps_default_mask()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/rps_default_mask");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_rps_sock_flow_entries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/rps_sock_flow_entries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_rps_sock_flow_entries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/rps_sock_flow_entries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_skb_defer_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/skb_defer_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_skb_defer_max()
{
	char command[256];
	sprintf(command, "echo 64 > /proc/sys/net/core/skb_defer_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_somaxconn(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/somaxconn", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_somaxconn()
{
	char command[256];
	sprintf(command, "echo 4096 > /proc/sys/net/core/somaxconn");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_tstamp_allow_data(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/tstamp_allow_data", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_tstamp_allow_data()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/core/tstamp_allow_data");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_txrehash(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/txrehash", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_txrehash()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/core/txrehash");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_warnings(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/warnings", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_warnings()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/core/warnings");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_wmem_default(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/wmem_default", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_wmem_default()
{
	char command[256];
	sprintf(command, "echo 212992 > /proc/sys/net/core/wmem_default");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_wmem_max(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/wmem_max", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_wmem_max()
{
	char command[256];
	sprintf(command, "echo 212992 > /proc/sys/net/core/wmem_max");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_xfrm_acq_expires(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/xfrm_acq_expires", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_xfrm_acq_expires()
{
	char command[256];
	sprintf(command, "echo 30 > /proc/sys/net/core/xfrm_acq_expires");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_xfrm_aevent_etime(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/xfrm_aevent_etime", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_xfrm_aevent_etime()
{
	char command[256];
	sprintf(command, "echo 10 > /proc/sys/net/core/xfrm_aevent_etime");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_xfrm_aevent_rseqth(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/xfrm_aevent_rseqth", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_xfrm_aevent_rseqth()
{
	char command[256];
	sprintf(command, "echo 2 > /proc/sys/net/core/xfrm_aevent_rseqth");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_core_xfrm_larval_drop(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/core/xfrm_larval_drop", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_core_xfrm_larval_drop()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/core/xfrm_larval_drop");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_cipso_cache_bucket_size(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/cipso_cache_bucket_size", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_cipso_cache_bucket_size()
{
	char command[256];
	sprintf(command, "echo 10 > /proc/sys/net/ipv4/cipso_cache_bucket_size");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_cipso_cache_enable(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/cipso_cache_enable", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_cipso_cache_enable()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/cipso_cache_enable");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_cipso_rbm_optfmt(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/cipso_rbm_optfmt", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_cipso_rbm_optfmt()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/cipso_rbm_optfmt");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_cipso_rbm_strictvalid(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/cipso_rbm_strictvalid", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_cipso_rbm_strictvalid()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/cipso_rbm_strictvalid");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_fib_multipath_hash_fields(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/fib_multipath_hash_fields", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_fib_multipath_hash_fields()
{
	char command[256];
	sprintf(command, "echo 7 > /proc/sys/net/ipv4/fib_multipath_hash_fields");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_fib_multipath_hash_policy(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/fib_multipath_hash_policy", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_fib_multipath_hash_policy()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/fib_multipath_hash_policy");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_fib_multipath_hash_seed(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/fib_multipath_hash_seed", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_fib_multipath_hash_seed()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/fib_multipath_hash_seed");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_fib_multipath_use_neigh(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/fib_multipath_use_neigh", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_fib_multipath_use_neigh()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/fib_multipath_use_neigh");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_fib_notify_on_flag_change(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/fib_notify_on_flag_change", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_fib_notify_on_flag_change()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/fib_notify_on_flag_change");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_fib_sync_mem(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/fib_sync_mem", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_fib_sync_mem()
{
	char command[256];
	sprintf(command, "echo 524288 > /proc/sys/net/ipv4/fib_sync_mem");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_fwmark_reflect(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/fwmark_reflect", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_fwmark_reflect()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/fwmark_reflect");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_echo_enable_probe(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_echo_enable_probe", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_echo_enable_probe()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/icmp_echo_enable_probe");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_echo_ignore_all(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_echo_ignore_all", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_echo_ignore_all()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_all");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_echo_ignore_broadcasts(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_echo_ignore_broadcasts()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_errors_use_inbound_ifaddr(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_errors_use_inbound_ifaddr", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_errors_use_inbound_ifaddr()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/icmp_errors_use_inbound_ifaddr");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_ignore_bogus_error_responses(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_ignore_bogus_error_responses()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_msgs_burst(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_msgs_burst", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_msgs_burst()
{
	char command[256];
	sprintf(command, "echo 50 > /proc/sys/net/ipv4/icmp_msgs_burst");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_msgs_per_sec(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_msgs_per_sec", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_msgs_per_sec()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/net/ipv4/icmp_msgs_per_sec");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_ratelimit(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_ratelimit", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_ratelimit()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/net/ipv4/icmp_ratelimit");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_icmp_ratemask(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/icmp_ratemask", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_icmp_ratemask()
{
	char command[256];
	sprintf(command, "echo 6168 > /proc/sys/net/ipv4/icmp_ratemask");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_igmp_link_local_mcast_reports(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/igmp_link_local_mcast_reports", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_igmp_link_local_mcast_reports()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/igmp_link_local_mcast_reports");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_igmp_max_memberships(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/igmp_max_memberships", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_igmp_max_memberships()
{
	char command[256];
	sprintf(command, "echo 20 > /proc/sys/net/ipv4/igmp_max_memberships");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_igmp_max_msf(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/igmp_max_msf", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_igmp_max_msf()
{
	char command[256];
	sprintf(command, "echo 10 > /proc/sys/net/ipv4/igmp_max_msf");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_igmp_qrv(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/igmp_qrv", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_igmp_qrv()
{
	char command[256];
	sprintf(command, "echo 2 > /proc/sys/net/ipv4/igmp_qrv");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_inet_peer_maxttl(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/inet_peer_maxttl", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_inet_peer_maxttl()
{
	char command[256];
	sprintf(command, "echo 600 > /proc/sys/net/ipv4/inet_peer_maxttl");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_inet_peer_minttl(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/inet_peer_minttl", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_inet_peer_minttl()
{
	char command[256];
	sprintf(command, "echo 120 > /proc/sys/net/ipv4/inet_peer_minttl");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_inet_peer_threshold(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/inet_peer_threshold", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_inet_peer_threshold()
{
	char command[256];
	sprintf(command, "echo 65664 > /proc/sys/net/ipv4/inet_peer_threshold");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_autobind_reuse(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_autobind_reuse", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_autobind_reuse()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/ip_autobind_reuse");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_default_ttl(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_default_ttl", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_default_ttl()
{
	char command[256];
	sprintf(command, "echo 64 > /proc/sys/net/ipv4/ip_default_ttl");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_dynaddr(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_dynaddr", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_dynaddr()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/ip_dynaddr");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_early_demux(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_early_demux", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_early_demux()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/ip_early_demux");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_forward(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_forward", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_forward()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/ip_forward");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_forward_update_priority(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_forward_update_priority", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_forward_update_priority()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/ip_forward_update_priority");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_forward_use_pmtu(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_forward_use_pmtu", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_forward_use_pmtu()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/ip_forward_use_pmtu");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_no_pmtu_disc(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_no_pmtu_disc", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_no_pmtu_disc()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/ip_no_pmtu_disc");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_nonlocal_bind(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_nonlocal_bind", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_nonlocal_bind()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/ip_nonlocal_bind");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ip_unprivileged_port_start(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ip_unprivileged_port_start", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ip_unprivileged_port_start()
{
	char command[256];
	sprintf(command, "echo 1024 > /proc/sys/net/ipv4/ip_unprivileged_port_start");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ipfrag_high_thresh(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ipfrag_high_thresh", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ipfrag_high_thresh()
{
	char command[256];
	sprintf(command, "echo 4194304 > /proc/sys/net/ipv4/ipfrag_high_thresh");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ipfrag_low_thresh(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ipfrag_low_thresh", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ipfrag_low_thresh()
{
	char command[256];
	sprintf(command, "echo 3145728 > /proc/sys/net/ipv4/ipfrag_low_thresh");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ipfrag_max_dist(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ipfrag_max_dist", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ipfrag_max_dist()
{
	char command[256];
	sprintf(command, "echo 64 > /proc/sys/net/ipv4/ipfrag_max_dist");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ipfrag_secret_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ipfrag_secret_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ipfrag_secret_interval()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/ipfrag_secret_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_ipfrag_time(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/ipfrag_time", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_ipfrag_time()
{
	char command[256];
	sprintf(command, "echo 30 > /proc/sys/net/ipv4/ipfrag_time");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_nexthop_compat_mode(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/nexthop_compat_mode", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_nexthop_compat_mode()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/nexthop_compat_mode");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_abort_on_overflow(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_abort_on_overflow", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_abort_on_overflow()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_abort_on_overflow");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_adv_win_scale(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_adv_win_scale", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_adv_win_scale()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_adv_win_scale");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_app_win(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_app_win", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_app_win()
{
	char command[256];
	sprintf(command, "echo 31 > /proc/sys/net/ipv4/tcp_app_win");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_autocorking(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_autocorking", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_autocorking()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_autocorking");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_backlog_ack_defer(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_backlog_ack_defer", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_backlog_ack_defer()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_backlog_ack_defer");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_base_mss(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_base_mss", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_base_mss()
{
	char command[256];
	sprintf(command, "echo 1024 > /proc/sys/net/ipv4/tcp_base_mss");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_challenge_ack_limit(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_challenge_ack_limit", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_challenge_ack_limit()
{
	char command[256];
	sprintf(command, "echo 2147483647 > /proc/sys/net/ipv4/tcp_challenge_ack_limit");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_child_ehash_entries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_child_ehash_entries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_child_ehash_entries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_child_ehash_entries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_comp_sack_delay_ns(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_comp_sack_delay_ns", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_comp_sack_delay_ns()
{
	char command[256];
	sprintf(command, "echo 1000000 > /proc/sys/net/ipv4/tcp_comp_sack_delay_ns");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_comp_sack_nr(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_comp_sack_nr", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_comp_sack_nr()
{
	char command[256];
	sprintf(command, "echo 44 > /proc/sys/net/ipv4/tcp_comp_sack_nr");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_comp_sack_slack_ns(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_comp_sack_slack_ns", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_comp_sack_slack_ns()
{
	char command[256];
	sprintf(command, "echo 100000 > /proc/sys/net/ipv4/tcp_comp_sack_slack_ns");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_dsack(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_dsack", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_dsack()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_dsack");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_early_demux(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_early_demux", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_early_demux()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_early_demux");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_early_retrans(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_early_retrans", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_early_retrans()
{
	char command[256];
	sprintf(command, "echo 3 > /proc/sys/net/ipv4/tcp_early_retrans");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_ecn(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_ecn", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_ecn()
{
	char command[256];
	sprintf(command, "echo 2 > /proc/sys/net/ipv4/tcp_ecn");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_ecn_fallback(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_ecn_fallback", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_ecn_fallback()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_ecn_fallback");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_fack(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_fack", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_fack()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_fack");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_fastopen(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_fastopen", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_fastopen()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_fastopen");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_fastopen_blackhole_timeout_sec(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_fastopen_blackhole_timeout_sec", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_fastopen_blackhole_timeout_sec()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_fastopen_blackhole_timeout_sec");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_fin_timeout(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_fin_timeout", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_fin_timeout()
{
	char command[256];
	sprintf(command, "echo 60 > /proc/sys/net/ipv4/tcp_fin_timeout");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_frto(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_frto", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_frto()
{
	char command[256];
	sprintf(command, "echo 2 > /proc/sys/net/ipv4/tcp_frto");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_fwmark_accept(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_fwmark_accept", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_fwmark_accept()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_fwmark_accept");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_invalid_ratelimit(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_invalid_ratelimit", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_invalid_ratelimit()
{
	char command[256];
	sprintf(command, "echo 500 > /proc/sys/net/ipv4/tcp_invalid_ratelimit");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_keepalive_intvl(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_keepalive_intvl", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_keepalive_intvl()
{
	char command[256];
	sprintf(command, "echo 75 > /proc/sys/net/ipv4/tcp_keepalive_intvl");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_keepalive_probes(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_keepalive_probes", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_keepalive_probes()
{
	char command[256];
	sprintf(command, "echo 9 > /proc/sys/net/ipv4/tcp_keepalive_probes");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_keepalive_time(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_keepalive_time", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_keepalive_time()
{
	char command[256];
	sprintf(command, "echo 7200 > /proc/sys/net/ipv4/tcp_keepalive_time");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_limit_output_bytes(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_limit_output_bytes", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_limit_output_bytes()
{
	char command[256];
	sprintf(command, "echo 1048576 > /proc/sys/net/ipv4/tcp_limit_output_bytes");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_low_latency(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_low_latency", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_low_latency()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_low_latency");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_max_orphans(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_max_orphans", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_max_orphans()
{
	char command[256];
	sprintf(command, "echo 8192 > /proc/sys/net/ipv4/tcp_max_orphans");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_max_reordering(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_max_reordering", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_max_reordering()
{
	char command[256];
	sprintf(command, "echo 300 > /proc/sys/net/ipv4/tcp_max_reordering");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_max_syn_backlog(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_max_syn_backlog", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_max_syn_backlog()
{
	char command[256];
	sprintf(command, "echo 128 > /proc/sys/net/ipv4/tcp_max_syn_backlog");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_max_tw_buckets(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_max_tw_buckets", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_max_tw_buckets()
{
	char command[256];
	sprintf(command, "echo 8192 > /proc/sys/net/ipv4/tcp_max_tw_buckets");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_migrate_req(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_migrate_req", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_migrate_req()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_migrate_req");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_min_rtt_wlen(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_min_rtt_wlen", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_min_rtt_wlen()
{
	char command[256];
	sprintf(command, "echo 300 > /proc/sys/net/ipv4/tcp_min_rtt_wlen");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_min_snd_mss(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_min_snd_mss", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_min_snd_mss()
{
	char command[256];
	sprintf(command, "echo 48 > /proc/sys/net/ipv4/tcp_min_snd_mss");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_min_tso_segs(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_min_tso_segs", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_min_tso_segs()
{
	char command[256];
	sprintf(command, "echo 2 > /proc/sys/net/ipv4/tcp_min_tso_segs");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_moderate_rcvbuf(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_moderate_rcvbuf", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_moderate_rcvbuf()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_moderate_rcvbuf");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_mtu_probe_floor(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_mtu_probe_floor", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_mtu_probe_floor()
{
	char command[256];
	sprintf(command, "echo 48 > /proc/sys/net/ipv4/tcp_mtu_probe_floor");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_mtu_probing(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_mtu_probing", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_mtu_probing()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_mtu_probing");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_no_metrics_save(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_no_metrics_save", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_no_metrics_save()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_no_metrics_save");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_no_ssthresh_metrics_save(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_no_ssthresh_metrics_save", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_no_ssthresh_metrics_save()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_no_ssthresh_metrics_save");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_notsent_lowat(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_notsent_lowat", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_notsent_lowat()
{
	char command[256];
	sprintf(command, "echo 4294967295 > /proc/sys/net/ipv4/tcp_notsent_lowat");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_orphan_retries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_orphan_retries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_orphan_retries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_orphan_retries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_pacing_ca_ratio(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_pacing_ca_ratio", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_pacing_ca_ratio()
{
	char command[256];
	sprintf(command, "echo 120 > /proc/sys/net/ipv4/tcp_pacing_ca_ratio");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_pacing_ss_ratio(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_pacing_ss_ratio", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_pacing_ss_ratio()
{
	char command[256];
	sprintf(command, "echo 200 > /proc/sys/net/ipv4/tcp_pacing_ss_ratio");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_pingpong_thresh(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_pingpong_thresh", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_pingpong_thresh()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_pingpong_thresh");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_plb_cong_thresh(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_plb_cong_thresh", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_plb_cong_thresh()
{
	char command[256];
	sprintf(command, "echo 128 > /proc/sys/net/ipv4/tcp_plb_cong_thresh");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_plb_enabled(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_plb_enabled", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_plb_enabled()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_plb_enabled");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_plb_idle_rehash_rounds(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_plb_idle_rehash_rounds", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_plb_idle_rehash_rounds()
{
	char command[256];
	sprintf(command, "echo 3 > /proc/sys/net/ipv4/tcp_plb_idle_rehash_rounds");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_plb_rehash_rounds(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_plb_rehash_rounds", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_plb_rehash_rounds()
{
	char command[256];
	sprintf(command, "echo 12 > /proc/sys/net/ipv4/tcp_plb_rehash_rounds");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_plb_suspend_rto_sec(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_plb_suspend_rto_sec", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_plb_suspend_rto_sec()
{
	char command[256];
	sprintf(command, "echo 60 > /proc/sys/net/ipv4/tcp_plb_suspend_rto_sec");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_probe_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_probe_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_probe_interval()
{
	char command[256];
	sprintf(command, "echo 600 > /proc/sys/net/ipv4/tcp_probe_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_probe_threshold(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_probe_threshold", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_probe_threshold()
{
	char command[256];
	sprintf(command, "echo 8 > /proc/sys/net/ipv4/tcp_probe_threshold");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_recovery(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_recovery", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_recovery()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_recovery");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_reflect_tos(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_reflect_tos", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_reflect_tos()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_reflect_tos");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_reordering(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_reordering", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_reordering()
{
	char command[256];
	sprintf(command, "echo 3 > /proc/sys/net/ipv4/tcp_reordering");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_retrans_collapse(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_retrans_collapse", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_retrans_collapse()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_retrans_collapse");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_retries1(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_retries1", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_retries1()
{
	char command[256];
	sprintf(command, "echo 3 > /proc/sys/net/ipv4/tcp_retries1");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_retries2(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_retries2", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_retries2()
{
	char command[256];
	sprintf(command, "echo 15 > /proc/sys/net/ipv4/tcp_retries2");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_rfc1337(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_rfc1337", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_rfc1337()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_rfc1337");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_rto_min_us(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_rto_min_us", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_rto_min_us()
{
	char command[256];
	sprintf(command, "echo 200000 > /proc/sys/net/ipv4/tcp_rto_min_us");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_sack(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_sack", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_sack()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_sack");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_shrink_window(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_shrink_window", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_shrink_window()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_shrink_window");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_slow_start_after_idle(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_slow_start_after_idle", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_slow_start_after_idle()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_slow_start_after_idle");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_stdurg(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_stdurg", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_stdurg()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_stdurg");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_syn_linear_timeouts(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_syn_linear_timeouts", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_syn_linear_timeouts()
{
	char command[256];
	sprintf(command, "echo 4 > /proc/sys/net/ipv4/tcp_syn_linear_timeouts");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_syn_retries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_syn_retries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_syn_retries()
{
	char command[256];
	sprintf(command, "echo 6 > /proc/sys/net/ipv4/tcp_syn_retries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_synack_retries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_synack_retries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_synack_retries()
{
	char command[256];
	sprintf(command, "echo 5 > /proc/sys/net/ipv4/tcp_synack_retries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_syncookies(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_syncookies", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_syncookies()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_syncookies");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_thin_linear_timeouts(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_thin_linear_timeouts", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_thin_linear_timeouts()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_thin_linear_timeouts");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_timestamps(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_timestamps", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_timestamps()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_timestamps");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_tso_rtt_log(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_tso_rtt_log", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_tso_rtt_log()
{
	char command[256];
	sprintf(command, "echo 9 > /proc/sys/net/ipv4/tcp_tso_rtt_log");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_tso_win_divisor(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_tso_win_divisor", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_tso_win_divisor()
{
	char command[256];
	sprintf(command, "echo 3 > /proc/sys/net/ipv4/tcp_tso_win_divisor");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_tw_reuse(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_tw_reuse", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_tw_reuse()
{
	char command[256];
	sprintf(command, "echo 2 > /proc/sys/net/ipv4/tcp_tw_reuse");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_window_scaling(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_window_scaling", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_window_scaling()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/tcp_window_scaling");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_tcp_workaround_signed_windows(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/tcp_workaround_signed_windows", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_tcp_workaround_signed_windows()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/tcp_workaround_signed_windows");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_udp_child_hash_entries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/udp_child_hash_entries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_udp_child_hash_entries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/udp_child_hash_entries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_udp_early_demux(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/udp_early_demux", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_udp_early_demux()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/udp_early_demux");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_udp_rmem_min(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/udp_rmem_min", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_udp_rmem_min()
{
	char command[256];
	sprintf(command, "echo 4096 > /proc/sys/net/ipv4/udp_rmem_min");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_udp_wmem_min(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/udp_wmem_min", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_udp_wmem_min()
{
	char command[256];
	sprintf(command, "echo 4096 > /proc/sys/net/ipv4/udp_wmem_min");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_xfrm4_gc_thresh(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/xfrm4_gc_thresh", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_xfrm4_gc_thresh()
{
	char command[256];
	sprintf(command, "echo 32768 > /proc/sys/net/ipv4/xfrm4_gc_thresh");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_accept_local(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/accept_local", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_accept_local()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/accept_local");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_accept_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/accept_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_accept_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/all/accept_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_accept_source_route(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/accept_source_route", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_accept_source_route()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/accept_source_route");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_arp_accept(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/arp_accept", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_arp_accept()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/arp_accept");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_arp_announce(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/arp_announce", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_arp_announce()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/arp_announce");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_arp_evict_nocarrier(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/arp_evict_nocarrier", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_arp_evict_nocarrier()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/all/arp_evict_nocarrier");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_arp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/arp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_arp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/arp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_arp_ignore(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/arp_ignore", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_arp_ignore()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/arp_ignore");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_arp_notify(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/arp_notify", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_arp_notify()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/arp_notify");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_bc_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/bc_forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_bc_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/bc_forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_bootp_relay(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/bootp_relay", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_bootp_relay()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/bootp_relay");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_disable_policy(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/disable_policy", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_disable_policy()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/disable_policy");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_disable_xfrm(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/disable_xfrm", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_disable_xfrm()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/disable_xfrm");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_drop_gratuitous_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/drop_gratuitous_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_drop_gratuitous_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/drop_gratuitous_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_drop_unicast_in_l2_multicast(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/drop_unicast_in_l2_multicast", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_drop_unicast_in_l2_multicast()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/drop_unicast_in_l2_multicast");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_force_igmp_version(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/force_igmp_version", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_force_igmp_version()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/force_igmp_version");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_igmpv2_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/igmpv2_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_igmpv2_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 10000 > /proc/sys/net/ipv4/conf/all/igmpv2_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_igmpv3_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/igmpv3_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_igmpv3_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/net/ipv4/conf/all/igmpv3_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_ignore_routes_with_linkdown(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/ignore_routes_with_linkdown", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_ignore_routes_with_linkdown()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/ignore_routes_with_linkdown");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_log_martians(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/log_martians", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_log_martians()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/log_martians");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_medium_id(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/medium_id", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_medium_id()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/medium_id");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_promote_secondaries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/promote_secondaries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_promote_secondaries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/promote_secondaries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_proxy_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/proxy_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_proxy_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/proxy_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_proxy_arp_pvlan(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/proxy_arp_pvlan", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_proxy_arp_pvlan()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/proxy_arp_pvlan");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_route_localnet(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/route_localnet", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_route_localnet()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/route_localnet");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_rp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/rp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_rp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/rp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_secure_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/secure_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_secure_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/all/secure_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_send_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/send_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_send_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/all/send_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_shared_media(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/shared_media", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_shared_media()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/all/shared_media");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_src_valid_mark(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/src_valid_mark", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_src_valid_mark()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/src_valid_mark");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_all_tag(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/all/tag", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_all_tag()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/all/tag");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_accept_local(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/accept_local", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_accept_local()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/accept_local");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_accept_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/accept_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_accept_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/default/accept_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_accept_source_route(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/accept_source_route", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_accept_source_route()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/default/accept_source_route");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_arp_accept(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/arp_accept", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_arp_accept()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/arp_accept");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_arp_announce(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/arp_announce", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_arp_announce()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/arp_announce");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_arp_evict_nocarrier(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/arp_evict_nocarrier", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_arp_evict_nocarrier()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/default/arp_evict_nocarrier");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_arp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/arp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_arp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/arp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_arp_ignore(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/arp_ignore", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_arp_ignore()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/arp_ignore");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_arp_notify(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/arp_notify", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_arp_notify()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/arp_notify");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_bc_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/bc_forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_bc_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/bc_forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_bootp_relay(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/bootp_relay", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_bootp_relay()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/bootp_relay");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_disable_policy(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/disable_policy", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_disable_policy()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/disable_policy");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_disable_xfrm(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/disable_xfrm", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_disable_xfrm()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/disable_xfrm");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_drop_gratuitous_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/drop_gratuitous_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_drop_gratuitous_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/drop_gratuitous_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_drop_unicast_in_l2_multicast(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/drop_unicast_in_l2_multicast", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_drop_unicast_in_l2_multicast()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/drop_unicast_in_l2_multicast");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_force_igmp_version(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/force_igmp_version", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_force_igmp_version()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/force_igmp_version");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_igmpv2_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/igmpv2_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_igmpv2_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 10000 > /proc/sys/net/ipv4/conf/default/igmpv2_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_igmpv3_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/igmpv3_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_igmpv3_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/net/ipv4/conf/default/igmpv3_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_ignore_routes_with_linkdown(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/ignore_routes_with_linkdown", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_ignore_routes_with_linkdown()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/ignore_routes_with_linkdown");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_log_martians(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/log_martians", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_log_martians()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/log_martians");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_medium_id(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/medium_id", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_medium_id()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/medium_id");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_promote_secondaries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/promote_secondaries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_promote_secondaries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/promote_secondaries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_proxy_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/proxy_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_proxy_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/proxy_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_proxy_arp_pvlan(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/proxy_arp_pvlan", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_proxy_arp_pvlan()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/proxy_arp_pvlan");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_route_localnet(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/route_localnet", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_route_localnet()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/route_localnet");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_rp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/rp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_rp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/rp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_secure_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/secure_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_secure_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/default/secure_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_send_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/send_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_send_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/default/send_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_shared_media(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/shared_media", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_shared_media()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/default/shared_media");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_src_valid_mark(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/src_valid_mark", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_src_valid_mark()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/src_valid_mark");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_default_tag(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/default/tag", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_default_tag()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/default/tag");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_accept_local(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/accept_local", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_accept_local()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/accept_local");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_accept_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/accept_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_accept_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/eth0/accept_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_accept_source_route(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/accept_source_route", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_accept_source_route()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/eth0/accept_source_route");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_arp_accept(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/arp_accept", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_arp_accept()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/arp_accept");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_arp_announce(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/arp_announce", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_arp_announce()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/arp_announce");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_arp_evict_nocarrier(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/arp_evict_nocarrier", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_arp_evict_nocarrier()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/eth0/arp_evict_nocarrier");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_arp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/arp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_arp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/arp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_arp_ignore(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/arp_ignore", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_arp_ignore()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/arp_ignore");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_arp_notify(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/arp_notify", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_arp_notify()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/arp_notify");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_bc_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/bc_forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_bc_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/bc_forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_bootp_relay(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/bootp_relay", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_bootp_relay()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/bootp_relay");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_disable_policy(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/disable_policy", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_disable_policy()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/disable_policy");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_disable_xfrm(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/disable_xfrm", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_disable_xfrm()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/disable_xfrm");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_drop_gratuitous_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/drop_gratuitous_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_drop_gratuitous_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/drop_gratuitous_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_drop_unicast_in_l2_multicast(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/drop_unicast_in_l2_multicast", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_drop_unicast_in_l2_multicast()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/drop_unicast_in_l2_multicast");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_force_igmp_version(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/force_igmp_version", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_force_igmp_version()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/force_igmp_version");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_igmpv2_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/igmpv2_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_igmpv2_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 10000 > /proc/sys/net/ipv4/conf/eth0/igmpv2_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_igmpv3_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/igmpv3_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_igmpv3_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/net/ipv4/conf/eth0/igmpv3_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_ignore_routes_with_linkdown(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/ignore_routes_with_linkdown", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_ignore_routes_with_linkdown()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/ignore_routes_with_linkdown");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_log_martians(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/log_martians", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_log_martians()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/log_martians");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_medium_id(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/medium_id", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_medium_id()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/medium_id");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_promote_secondaries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/promote_secondaries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_promote_secondaries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/promote_secondaries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_proxy_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/proxy_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_proxy_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/proxy_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_proxy_arp_pvlan(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/proxy_arp_pvlan", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_proxy_arp_pvlan()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/proxy_arp_pvlan");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_route_localnet(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/route_localnet", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_route_localnet()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/route_localnet");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_rp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/rp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_rp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/rp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_secure_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/secure_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_secure_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/eth0/secure_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_send_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/send_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_send_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/eth0/send_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_shared_media(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/shared_media", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_shared_media()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/eth0/shared_media");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_src_valid_mark(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/src_valid_mark", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_src_valid_mark()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/src_valid_mark");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_eth0_tag(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/eth0/tag", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_eth0_tag()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/eth0/tag");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_accept_local(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/accept_local", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_accept_local()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/accept_local");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_accept_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/accept_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_accept_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/lo/accept_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_accept_source_route(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/accept_source_route", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_accept_source_route()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/lo/accept_source_route");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_arp_accept(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/arp_accept", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_arp_accept()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/arp_accept");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_arp_announce(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/arp_announce", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_arp_announce()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/arp_announce");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_arp_evict_nocarrier(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/arp_evict_nocarrier", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_arp_evict_nocarrier()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/lo/arp_evict_nocarrier");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_arp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/arp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_arp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/arp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_arp_ignore(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/arp_ignore", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_arp_ignore()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/arp_ignore");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_arp_notify(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/arp_notify", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_arp_notify()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/arp_notify");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_bc_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/bc_forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_bc_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/bc_forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_bootp_relay(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/bootp_relay", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_bootp_relay()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/bootp_relay");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_disable_policy(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/disable_policy", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_disable_policy()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/lo/disable_policy");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_disable_xfrm(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/disable_xfrm", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_disable_xfrm()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/lo/disable_xfrm");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_drop_gratuitous_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/drop_gratuitous_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_drop_gratuitous_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/drop_gratuitous_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_drop_unicast_in_l2_multicast(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/drop_unicast_in_l2_multicast", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_drop_unicast_in_l2_multicast()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/drop_unicast_in_l2_multicast");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_force_igmp_version(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/force_igmp_version", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_force_igmp_version()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/force_igmp_version");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_igmpv2_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/igmpv2_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_igmpv2_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 10000 > /proc/sys/net/ipv4/conf/lo/igmpv2_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_igmpv3_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/igmpv3_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_igmpv3_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/net/ipv4/conf/lo/igmpv3_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_ignore_routes_with_linkdown(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/ignore_routes_with_linkdown", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_ignore_routes_with_linkdown()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/ignore_routes_with_linkdown");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_log_martians(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/log_martians", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_log_martians()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/log_martians");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_medium_id(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/medium_id", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_medium_id()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/medium_id");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_promote_secondaries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/promote_secondaries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_promote_secondaries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/promote_secondaries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_proxy_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/proxy_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_proxy_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/proxy_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_proxy_arp_pvlan(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/proxy_arp_pvlan", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_proxy_arp_pvlan()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/proxy_arp_pvlan");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_route_localnet(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/route_localnet", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_route_localnet()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/route_localnet");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_rp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/rp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_rp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/rp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_secure_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/secure_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_secure_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/lo/secure_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_send_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/send_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_send_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/lo/send_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_shared_media(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/shared_media", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_shared_media()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/lo/shared_media");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_src_valid_mark(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/src_valid_mark", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_src_valid_mark()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/src_valid_mark");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_lo_tag(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/lo/tag", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_lo_tag()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/lo/tag");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_accept_local(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/accept_local", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_accept_local()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/accept_local");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_accept_redirects(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/accept_redirects", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_accept_redirects()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/sit0/accept_redirects");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_accept_source_route(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/accept_source_route", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_accept_source_route()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/sit0/accept_source_route");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_arp_accept(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/arp_accept", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_arp_accept()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/arp_accept");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_arp_announce(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/arp_announce", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_arp_announce()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/arp_announce");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_arp_evict_nocarrier(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/arp_evict_nocarrier", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_arp_evict_nocarrier()
{
	char command[256];
	sprintf(command, "echo 1 > /proc/sys/net/ipv4/conf/sit0/arp_evict_nocarrier");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_arp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/arp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_arp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/arp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_arp_ignore(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/arp_ignore", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_arp_ignore()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/arp_ignore");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_arp_notify(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/arp_notify", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_arp_notify()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/arp_notify");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_bc_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/bc_forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_bc_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/bc_forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_bootp_relay(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/bootp_relay", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_bootp_relay()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/bootp_relay");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_disable_policy(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/disable_policy", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_disable_policy()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/disable_policy");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_disable_xfrm(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/disable_xfrm", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_disable_xfrm()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/disable_xfrm");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_drop_gratuitous_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/drop_gratuitous_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_drop_gratuitous_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/drop_gratuitous_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_drop_unicast_in_l2_multicast(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/drop_unicast_in_l2_multicast", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_drop_unicast_in_l2_multicast()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/drop_unicast_in_l2_multicast");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_force_igmp_version(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/force_igmp_version", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_force_igmp_version()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/force_igmp_version");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_forwarding(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/forwarding", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_forwarding()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/forwarding");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_igmpv2_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/igmpv2_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_igmpv2_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 10000 > /proc/sys/net/ipv4/conf/sit0/igmpv2_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_igmpv3_unsolicited_report_interval(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/igmpv3_unsolicited_report_interval", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_igmpv3_unsolicited_report_interval()
{
	char command[256];
	sprintf(command, "echo 1000 > /proc/sys/net/ipv4/conf/sit0/igmpv3_unsolicited_report_interval");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_ignore_routes_with_linkdown(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/ignore_routes_with_linkdown", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_ignore_routes_with_linkdown()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/ignore_routes_with_linkdown");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_log_martians(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/log_martians", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_log_martians()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/log_martians");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_medium_id(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/medium_id", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_medium_id()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/medium_id");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_promote_secondaries(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/promote_secondaries", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_promote_secondaries()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/promote_secondaries");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_proxy_arp(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/proxy_arp", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_proxy_arp()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/proxy_arp");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_proxy_arp_pvlan(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/proxy_arp_pvlan", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_proxy_arp_pvlan()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/proxy_arp_pvlan");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_route_localnet(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/route_localnet", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_route_localnet()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/route_localnet");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_set__proc_sys_net_ipv4_conf_sit0_rp_filter(volatile long val)
{
	char command[256];
	sprintf(command, "echo %ld > /proc/sys/net/ipv4/conf/sit0/rp_filter", val);
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}


static long syz_sysconfig_reset__proc_sys_net_ipv4_conf_sit0_rp_filter()
{
	char command[256];
	sprintf(command, "echo 0 > /proc/sys/net/ipv4/conf/sit0/rp_filter");
	int ret = system(command);
	if (ret != 0) {
		return 0;
	}
	return 0;
}